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
TypeScript a2aai-agentsai-gatewayanthropicclaudeclaude-codeclinecodexcopilotcursordeepseekfree-aigeminikimillm-gatewaymcpopenaiopenai-proxyqwentoken-saver
fix(compression): support Responses input and expand Spanish rules (#2028)
Raxxoor831829dbc345
diff --git a/open-sse/handlers/chatCore.ts b/open-sse/handlers/chatCore.tsindex 5b53373d74..8cc02b794a 100644--- a/open-sse/handlers/chatCore.ts+++ b/open-sse/handlers/chatCore.ts@@ -44,6 +44,7 @@ import { isDetailedLoggingEnabled } from "@/lib/db/detailedLogs";import { getCallLogPipelineCaptureStreamChunks } from "@/lib/logEnv";import { logAuditEvent } from "@/lib/compliance";import { extractProviderWarnings } from "@/lib/compliance/providerAudit";+import { adaptBodyForCompression } from "../services/compression/bodyAdapter.ts";import { handleBypassRequest } from "../utils/bypassHandler.ts";import {saveRequestUsage,@@ -1614,8 +1615,9 @@ export async function handleChatCore({// ── Proactive Context Compression (Phase 4) ──// Check if context exceeds 70% of limit and compress proactively before sending to provider.// This prevents "prompt too long" errors for large-but-not-full contexts.+ const compressionBody = body ? adaptBodyForCompression(body as Record<string, unknown>).body : null;const allMessages =- body?.messages || body?.input || body?.contents || body?.request?.contents || [];+ compressionBody?.messages || body?.contents || body?.request?.contents || [];let cavemanOutputModeApplied = false;let cavemanOutputModeIntensity: string | null = null;if (body && Array.isArray(allMessages) && allMessages.length > 0) {@@ -1898,6 +1900,7 @@ export async function handleChatCore({0,result.stats.originalTokens - result.stats.compressedTokens);+ const rtkPointers = result.stats.rtkRawOutputPointers ?? [];const estimatedUsdSaved = await calculateCost(provider ?? "",effectiveModel ?? "",@@ -1921,8 +1924,14 @@ export async function handleChatCore({estimated_usd_saved: estimatedUsdSaved || null,validation_fallback: result.stats.fallbackApplied ? 1 : 0,output_mode: cavemanOutputModeApplied ? cavemanOutputModeIntensity : null,- rtk_raw_output_pointer: result.stats.rtkRawOutputPointers?.[0]?.id ?? null,- rtk_raw_output_bytes: result.stats.rtkRawOutputPointers?.[0]?.bytes ?? null,+ rtk_raw_output_pointer: rtkPointers[0]?.id ?? null,+ rtk_raw_output_bytes: rtkPointers[0]?.bytes ?? null,+ rtk_raw_output_pointers: rtkPointers.length+ ? JSON.stringify(rtkPointers.map((pointer) => pointer.id))+ : null,+ rtk_raw_output_total_bytes: rtkPointers.length+ ? rtkPointers.reduce((total, pointer) => total + pointer.bytes, 0)+ : null,});} catch (err) {log?.debug?.(diff --git a/open-sse/services/compression/bodyAdapter.ts b/open-sse/services/compression/bodyAdapter.tsnew file mode 100644index 0000000000..2a65c21a94--- /dev/null+++ b/open-sse/services/compression/bodyAdapter.ts@@ -0,0 +1,160 @@+type MessageLike = {+ role?: unknown;+ content?: unknown;+ [COMPRESSION_INPUT_INDEX]?: number;+ [key: string]: unknown;+};++type ResponsesItem = {+ type?: unknown;+ role?: unknown;+ content?: unknown;+ output?: unknown;+ [key: string]: unknown;+};++const RESPONSES_MESSAGE_TYPES = new Set(["message", "function_call_output"]);+const COMPRESSION_INPUT_INDEX = Symbol("compressionInputIndex");++function isRecord(value: unknown): value is Record<string, unknown> {+ return !!value && typeof value === "object" && !Array.isArray(value);+}++function normalizeRole(role: unknown, fallback: string): string {+ return typeof role === "string" && role.length > 0 ? role : fallback;+}++function toChatContent(content: unknown, fallbackOutput?: unknown): unknown {+ return content === undefined ? fallbackOutput : content;+}++function fromChatContent(nextContent: unknown, originalContent: unknown): unknown {+ if (Array.isArray(originalContent) && typeof nextContent === "string") {+ let replaced = false;+ const mapped = originalContent.map((part) => {+ if (!isRecord(part) || typeof part.text !== "string") return part;+ if (replaced) return { ...part, text: "" };+ replaced = true;+ return { ...part, text: nextContent };+ });+ return replaced ? mapped : originalContent;+ }+ return nextContent;+}++function responsesItemToMessage(item: ResponsesItem): MessageLike | null {+ const type = typeof item.type === "string" ? item.type : "message";+ if (!RESPONSES_MESSAGE_TYPES.has(type)) return null;++ if (type === "function_call_output") {+ return {+ role: "tool",+ content: toChatContent(item.output ?? item.content),+ };+ }++ return {+ role: normalizeRole(item.role, "user"),+ content: toChatContent(item.content, item.output),+ };+}++function messageToResponsesItem(message: MessageLike, originalItem: ResponsesItem): ResponsesItem {+ const type = typeof originalItem.type === "string" ? originalItem.type : "message";+ if (type === "function_call_output") {+ return {+ ...originalItem,+ output: fromChatContent(message.content, originalItem.output),+ };+ }++ return {+ ...originalItem,+ content: fromChatContent(message.content, originalItem.content),+ };+}++function hasTextContent(message: MessageLike): boolean {+ if (typeof message.content === "string") return message.content.length > 0;+ if (!Array.isArray(message.content)) return false;+ return message.content.some(+ (part) => isRecord(part) && typeof part.text === "string" && part.text.length > 0+ );+}++export type CompressionBodyAdapter = {+ body: Record<string, unknown>;+ adapted: boolean;+ restore(compressedBody: Record<string, unknown>): Record<string, unknown>;+};++export function adaptBodyForCompression(body: Record<string, unknown>): CompressionBodyAdapter {+ if (Array.isArray(body.messages)) {+ return {+ body,+ adapted: false,+ restore: (compressedBody) => compressedBody,+ };+ }++ if (!Array.isArray(body.input) && typeof body.input !== "string") {+ return {+ body,+ adapted: false,+ restore: (compressedBody) => compressedBody,+ };+ }++ const inputItems = Array.isArray(body.input)+ ? body.input+ : [{ type: "message", role: "user", content: body.input }];+ const mappings: Array<{ index: number; item: ResponsesItem }> = [];+ const messages: MessageLike[] = [];++ inputItems.forEach((item, index) => {+ if (!isRecord(item)) return;+ const message = responsesItemToMessage(item);+ if (!message || !hasTextContent(message)) return;+ mappings.push({ index, item: item as ResponsesItem });+ messages.push({ ...message, [COMPRESSION_INPUT_INDEX]: index });+ });++ if (messages.length === 0) {+ return {+ body,+ adapted: false,+ restore: (compressedBody) => compressedBody,+ };+ }++ const bodyWithoutInput = { ...body };+ delete bodyWithoutInput.input;++ return {+ body: { ...bodyWithoutInput, messages },+ adapted: true,+ restore(compressedBody) {+ const compressedMessagesByIndex = new Map<number, MessageLike>();+ if (Array.isArray(compressedBody.messages)) {+ for (const message of compressedBody.messages as MessageLike[]) {+ if (typeof message[COMPRESSION_INPUT_INDEX] === "number") {+ compressedMessagesByIndex.set(message[COMPRESSION_INPUT_INDEX], message);+ }+ }+ }+ const nextInput = [...inputItems];+ mappings.forEach((mapping) => {+ const compressedMessage = compressedMessagesByIndex.get(mapping.index);+ if (!compressedMessage) return;+ nextInput[mapping.index] = messageToResponsesItem(compressedMessage, mapping.item);+ });+ const rest = { ...compressedBody };+ delete rest.messages;+ if (typeof body.input === "string") {+ const first = nextInput[0];+ return { ...rest, input: isRecord(first) ? (first.content ?? body.input) : body.input };+ }+ return { ...rest, input: nextInput };+ },+ };+}diff --git a/open-sse/services/compression/engines/cavemanAdapter.ts b/open-sse/services/compression/engines/cavemanAdapter.tsindex 51ae2b6548..6bab174e56 100644--- a/open-sse/services/compression/engines/cavemanAdapter.ts+++ b/open-sse/services/compression/engines/cavemanAdapter.ts@@ -3,6 +3,7 @@ import { cavemanCompress } from "../caveman.ts";import { compressAggressive } from "../aggressive.ts";import { ultraCompress } from "../ultra.ts";import { createCompressionStats } from "../stats.ts";+import { adaptBodyForCompression } from "../bodyAdapter.ts";import {DEFAULT_AGGRESSIVE_CONFIG,DEFAULT_ULTRA_CONFIG,@@ -228,10 +229,12 @@ export const liteEngine: CompressionEngine = {stable: true,},apply(body, options) {- return applyLiteCompression(body, {+ const adapter = adaptBodyForCompression(body);+ const result = applyLiteCompression(adapter.body, {...options,preserveSystemPrompt: options?.config?.preserveSystemPrompt !== false,});+ return adapter.adapted ? { ...result, body: adapter.restore(result.body) } : result;},compress(body, config) {return this.apply(body, { stepConfig: config });@@ -262,6 +265,7 @@ export const cavemanEngine: CompressionEngine = {stable: true,},apply(body, options) {+ const adapter = adaptBodyForCompression(body);const cavemanConfig = {...(options?.config?.cavemanConfig ?? {}),...(options?.stepConfig ?? {}),@@ -280,7 +284,11 @@ export const cavemanEngine: CompressionEngine = {}: {}),};- return cavemanCompress(body as Parameters<typeof cavemanCompress>[0], cavemanConfig);+ const result = cavemanCompress(+ adapter.body as Parameters<typeof cavemanCompress>[0],+ cavemanConfig+ );+ return adapter.adapted ? { ...result, body: adapter.restore(result.body) } : result;},compress(body, config) {return this.apply(body, { stepConfig: config });@@ -311,7 +319,8 @@ export const aggressiveEngine: CompressionEngine = {stable: true,},apply(body, options) {- const messages = (body.messages ?? []) as Array<{+ const adapter = adaptBodyForCompression(body);+ const messages = (adapter.body.messages ?? []) as Array<{role: string;content?: string | Array<{ type: string; text?: string }>;[key: string]: unknown;@@ -325,12 +334,12 @@ export const aggressiveEngine: CompressionEngine = {preserveSystemPrompt: options?.config?.preserveSystemPrompt !== false,};const result = compressAggressive(messages, aggressiveConfig);- const compressedBody = { ...body, messages: result.messages };+ const compressedBody = { ...adapter.body, messages: result.messages };return {- body: compressedBody,+ body: adapter.restore(compressedBody),compressed: result.stats.savingsPercent > 0,stats: createCompressionStats(- body,+ adapter.body,compressedBody,"aggressive",["aggressive"],@@ -368,7 +377,8 @@ export const ultraEngine: CompressionEngine = {stable: true,},apply(body, options) {- const messages = (body.messages ?? []) as Array<{+ const adapter = adaptBodyForCompression(body);+ const messages = (adapter.body.messages ?? []) as Array<{role: string;content?: string | unknown[];[key: string]: unknown;@@ -382,12 +392,12 @@ export const ultraEngine: CompressionEngine = {preserveSystemPrompt: options?.config?.preserveSystemPrompt !== false,};const result = ultraCompress(messages, ultraConfig);- const compressedBody = { ...body, messages: result.messages };+ const compressedBody = { ...adapter.body, messages: result.messages };return {- body: compressedBody,+ body: adapter.restore(compressedBody),compressed: result.stats.savingsPercent > 0,stats: createCompressionStats(- body,+ adapter.body,compressedBody,"ultra",["ultra"],diff --git a/open-sse/services/compression/engines/rtk/codeStripper.ts b/open-sse/services/compression/engines/rtk/codeStripper.tsindex 27c3512910..360b5bdd32 100644--- a/open-sse/services/compression/engines/rtk/codeStripper.ts+++ b/open-sse/services/compression/engines/rtk/codeStripper.ts@@ -50,40 +50,6 @@ export function detectCodeLanguage(text: string): CodeLanguage {return "unknown";}-function removeSlashComments(text: string): string {- return text- .replace(/\/\*[\s\S]*?\*\//g, "")- .replace(/^\s*\/\/.*$/gm, "")- .replace(/\s+\/\/\s.*$/gm, "");-}--function removeHashComments(text: string): string {- return text.replace(/^\s*#.*$/gm, "").replace(/\s+#\s.*$/gm, "");-}--function stripByLanguage(- text: string,- language: CodeLanguage,- options: Required<CodeStripperOptions>-): string {- if (!options.removeComments) return text;-- if (language === "javascript" || language === "typescript" || language === "rust") {- return removeSlashComments(text);- }- if (language === "go" || language === "java") return removeSlashComments(text);- if (language === "python") {- const withoutDocstrings = options.preserveDocstrings- ? text- : text.replace(/("""[\s\S]*?"""|'''[\s\S]*?''')/g, "");- return removeHashComments(withoutDocstrings);- }- if (language === "ruby") {- return removeHashComments(text.replace(/^=begin[\s\S]*?^=end/gm, ""));- }- return text;-}-export function stripCode(text: string,language: CodeLanguage = "unknown",@@ -101,7 +67,7 @@ export function stripCode(preserveDocstrings: options.preserveDocstrings === true,};const originalLines = text.split(/\r?\n/).length;- let result = stripByLanguage(text, resolvedLanguage, opts);+ let result = text;if (opts.removeEmptyLines) result = result.replace(/^\s*$(?:\r?\n)?/gm, "");if (opts.collapseWhitespace) {@@ -111,7 +77,7 @@ export function stripCode(.join("\n");}- result = result.trim();+ result = result.replace(/^\s*\n/, "").replace(/\n\s*$/, "");const strippedLines = Math.max(0, originalLines - (result ? result.split(/\r?\n/).length : 0));return { text: result, strippedLines, language: resolvedLanguage };}diff --git a/open-sse/services/compression/engines/rtk/index.ts b/open-sse/services/compression/engines/rtk/index.tsindex 70d6efc529..1b851bc69f 100644--- a/open-sse/services/compression/engines/rtk/index.ts+++ b/open-sse/services/compression/engines/rtk/index.ts@@ -9,6 +9,7 @@ import { smartTruncate } from "./smartTruncate.ts";import { normalizeCodeLanguage, stripCode } from "./codeStripper.ts";import { maybePersistRtkRawOutput, type RtkRawOutputPointer } from "./rawOutput.ts";import { isTextBlock } from "../../messageContent.ts";+import { adaptBodyForCompression } from "../../bodyAdapter.ts";type Message = {role: string;@@ -186,12 +187,81 @@ function mergeRtkConfig(base?: Partial<RtkConfig>, override?: Record<string, unk}function shouldCompressMessage(message: Message, config: RtkConfig): boolean {- if (message.role === "tool") return config.applyToToolResults || config.applyToCodeBlocks;+ if (message.role === "tool")+ return config.applyToToolResults || (config.applyToCodeBlocks && hasCodeFence(message.content));if (message.role === "assistant")- return config.applyToAssistantMessages || config.applyToCodeBlocks;+ return config.applyToAssistantMessages || (config.applyToCodeBlocks && hasCodeFence(message.content));return false;}+function hasCodeFence(content: Message["content"]): boolean {+ if (!content) return false;+ if (typeof content === "string") return /```/.test(content);+ if (!Array.isArray(content)) return false;+ return content.some((part) => isTextBlock(part) && typeof part.text === "string" && /```/.test(part.text));+}++function codeOnlyConfig(config: RtkConfig): boolean {+ return config.applyToCodeBlocks && !config.applyToToolResults && !config.applyToAssistantMessages;+}++function processRtkCodeBlocksOnly(+ content: Message["content"],+ config: RtkConfig+): {+ content: Message["content"];+ compressed: boolean;+ techniquesUsed: string[];+ rulesApplied: string[];+ rawOutputPointers: RtkRawOutputPointer[];+} {+ const techniquesUsed: string[] = [];+ const rulesApplied: string[] = [];+ const rawOutputPointers: RtkRawOutputPointer[] = [];+ const processText = (text: string) => {+ let compressed = false;+ const nextText = text.replace(/```([\s\S]*?)```/g, (match) => {+ const processed = processRtkText(match, { config });+ techniquesUsed.push(...processed.techniquesUsed);+ rulesApplied.push(...processed.rulesApplied);+ if (processed.rawOutputPointers) rawOutputPointers.push(...processed.rawOutputPointers);+ if (!processed.compressed) return match;+ compressed = true;+ return processed.text;+ });+ return { text: compressed ? nextText : text, compressed };+ };++ if (typeof content === "string") {+ const processed = processText(content);+ return {+ content: processed.text,+ compressed: processed.compressed,+ techniquesUsed,+ rulesApplied,+ rawOutputPointers,+ };+ }+ if (!Array.isArray(content)) {+ return { content, compressed: false, techniquesUsed, rulesApplied, rawOutputPointers };+ }+ let compressed = false;+ const nextContent = content.map((part) => {+ if (!isTextBlock(part) || !part.text) return part;+ const processed = processText(part.text);+ if (!processed.compressed) return part;+ compressed = true;+ return { ...part, text: processed.text };+ });+ return {+ content: compressed ? nextContent : content,+ compressed,+ techniquesUsed,+ rulesApplied,+ rawOutputPointers,+ };+}+export function processRtkText(text: string,options: { command?: string | null; config?: Partial<RtkConfig> } = {}@@ -296,6 +366,9 @@ function processRtkContent(rulesApplied: string[];rawOutputPointers: RtkRawOutputPointer[];} {+ if (codeOnlyConfig(config)) {+ return processRtkCodeBlocksOnly(content, config);+ }const techniquesUsed: string[] = [];const rulesApplied: string[] = [];const rawOutputPointers: RtkRawOutputPointer[] = [];@@ -352,7 +425,8 @@ export function applyRtkCompression(const config = mergeRtkConfig(options.config, options.stepConfig);if (!config.enabled) return { body, compressed: false, stats: null };- const messages = body.messages as Message[] | undefined;+ const adapter = adaptBodyForCompression(body);+ const messages = adapter.body.messages as Message[] | undefined;if (!Array.isArray(messages) || messages.length === 0) {return { body, compressed: false, stats: null };}@@ -373,9 +447,9 @@ export function applyRtkCompression(};});- const compressedBody = { ...body, messages: compressedMessages };+ const compressedBody = { ...adapter.body, messages: compressedMessages };const stats = createCompressionStats(- body,+ adapter.body,compressedBody,"rtk",[...new Set(allTechniques)],@@ -387,7 +461,7 @@ export function applyRtkCompression(stats.rtkRawOutputPointers = rawOutputPointers;}return {- body: compressedBody,+ body: adapter.restore(compressedBody),compressed: stats.compressedTokens < stats.originalTokens,stats,};diff --git a/open-sse/services/compression/outputMode.ts b/open-sse/services/compression/outputMode.tsindex 9f4e7bfe45..10b4ae1d47 100644--- a/open-sse/services/compression/outputMode.ts+++ b/open-sse/services/compression/outputMode.ts@@ -116,6 +116,7 @@ export function applyCavemanOutputMode(const messages = Array.isArray(body.messages) ? body.messages : null;if (!messages || messages.length === 0) {+ const instruction = buildCavemanOutputInstruction(config, language);if (typeof body.instructions === "string") {if (body.instructions.includes(CAVEMAN_OUTPUT_MARKER)) {return { body, applied: false, skippedReason: "already_applied" };@@ -123,11 +124,14 @@ export function applyCavemanOutputMode(return {body: {...body,- instructions: `${body.instructions.trim()}\n\n${buildCavemanOutputInstruction(config, language)}`,+ instructions: `${body.instructions.trim()}\n\n${instruction}`,},applied: true,};}+ if (typeof body.input === "string" || Array.isArray(body.input)) {+ return { body: { ...body, instructions: instruction }, applied: true };+ }return { body, applied: false, skippedReason: "no_messages" };}diff --git a/open-sse/services/compression/rules/es/context.json b/open-sse/services/compression/rules/es/context.jsonindex 980da607a7..0ef5a8ed33 100644--- a/open-sse/services/compression/rules/es/context.json+++ b/open-sse/services/compression/rules/es/context.json@@ -33,6 +33,55 @@"context": "all","category": "context","minIntensity": "lite"+ },+ {+ "name": "es_compound_collapse",+ "pattern": "\\by cualquier potencial\\b",+ "replacement": "",+ "context": "all",+ "category": "context",+ "minIntensity": "full"+ },+ {+ "name": "es_explanatory_prefix",+ "pattern": "\\b(?:la funcion parece manejar|la función parece manejar|el codigo parece|el código parece|la clase es|este modulo es|este módulo es)\\b",+ "replacement": "Función:",+ "replacementMap": {+ "la funcion parece manejar": "Función:",+ "la función parece manejar": "Función:",+ "el codigo parece": "Código:",+ "el código parece": "Código:",+ "la clase es": "Clase:",+ "este modulo es": "Módulo:",+ "este módulo es": "Módulo:"+ },+ "context": "all",+ "category": "context",+ "minIntensity": "lite"+ },+ {+ "name": "es_meta_commentary",+ "pattern": "^(?:Ten en cuenta que|Recuerda que|Nota que)\\b\\s*",+ "replacement": "",+ "context": "all",+ "category": "context",+ "minIntensity": "lite"+ },+ {+ "name": "es_purpose_statement",+ "pattern": "\\b(?:con el proposito de|con el propósito de|con la meta de|con el objetivo de|en un esfuerzo por|por cada)\\b",+ "replacement": "para",+ "replacementMap": {+ "con el proposito de": "para",+ "con el propósito de": "para",+ "con la meta de": "para",+ "con el objetivo de": "para",+ "en un esfuerzo por": "para",+ "por cada": "por"+ },+ "context": "all",+ "category": "context",+ "minIntensity": "lite"}]}diff --git a/open-sse/services/compression/rules/es/dedup.json b/open-sse/services/compression/rules/es/dedup.jsonnew file mode 100644index 0000000000..ac5e52239d--- /dev/null+++ b/open-sse/services/compression/rules/es/dedup.json@@ -0,0 +1,38 @@+{+ "language": "es",+ "category": "dedup",+ "rules": [+ {+ "name": "es_repeated_context",+ "pattern": "\\b(?:como mencionamos antes|como se menciono antes|como se mencionó antes|como dije antes|como comentamos anteriormente)\\b[,.]?\\s*",+ "replacement": "Ver arriba. ",+ "context": "all",+ "category": "dedup",+ "minIntensity": "lite"+ },+ {+ "name": "es_repeated_question",+ "pattern": "\\b(?:misma pregunta que antes|pregunte esto antes|pregunté esto antes|esta es la misma pregunta|es la misma pregunta)\\b[,.]?\\s*",+ "replacement": "[misma pregunta] ",+ "context": "user",+ "category": "dedup",+ "minIntensity": "lite"+ },+ {+ "name": "es_reestablished_context",+ "pattern": "\\b(?:volviendo al codigo anterior|volviendo al código anterior|refiriendome a|refiriéndome a|retomando)\\b\\s*",+ "replacement": "Re: ",+ "context": "all",+ "category": "dedup",+ "minIntensity": "lite"+ },+ {+ "name": "es_summary_replacement",+ "pattern": "\\b(?:para resumir lo que hemos hablado|en resumen de nuestra conversacion|en resumen de nuestra conversación|recapitulando)\\b[,.]?\\s*",+ "replacement": "Resumen: ",+ "context": "assistant",+ "category": "dedup",+ "minIntensity": "lite"+ }+ ]+}diff --git a/open-sse/services/compression/rules/es/filler.json b/open-sse/services/compression/rules/es/filler.jsonindex dee16e9e56..cf612f1ce0 100644--- a/open-sse/services/compression/rules/es/filler.json+++ b/open-sse/services/compression/rules/es/filler.json@@ -65,6 +65,46 @@"context": "all","category": "filler","minIntensity": "lite"+ },+ {+ "name": "es_verbose_instructions",+ "pattern": "\\b(?:proporciona una explicacion detallada de|proporciona una explicación detallada de|dame una explicacion completa de|dame una explicación completa de|escribe una explicacion en profundidad de|escribe una explicación en profundidad de|crea una explicacion exhaustiva de|crea una explicación exhaustiva de|explica en detalle)\\b",+ "replacement": "explica ",+ "context": "all",+ "category": "filler",+ "minIntensity": "lite"+ },+ {+ "name": "es_redundant_openers",+ "pattern": "^(?:hola|buenos dias|buenos días|buenas tardes|buenas|hey)\\s*[,.!?\\s]?\\s*",+ "replacement": "",+ "context": "user",+ "category": "filler",+ "minIntensity": "lite"+ },+ {+ "name": "es_excessive_gratitude",+ "pattern": "\\b(?:muchisimas gracias|muchísimas gracias|gracias de antemano|te lo agradezco mucho|lo agradezco mucho)\\b[,.!?\\s]*",+ "replacement": "",+ "context": "all",+ "category": "filler",+ "minIntensity": "lite"+ },+ {+ "name": "es_uncertainty_fillers",+ "pattern": "\\b(?:supongo que|imagino que|me da la impresion de que|me da la impresión de que|quizas|quizás)\\b\\s*",+ "replacement": "",+ "context": "all",+ "category": "filler",+ "minIntensity": "lite"+ },+ {+ "name": "es_assistant_fillers",+ "pattern": "^(?:aqui tienes|aquí tienes|debajo esta|debajo está|esto es)\\s+(?:un|una|el|la)?\\s*",+ "replacement": "",+ "context": "assistant",+ "category": "filler",+ "minIntensity": "lite"}]}diff --git a/open-sse/services/compression/rules/es/structural.json b/open-sse/services/compression/rules/es/structural.jsonindex f1d2454043..759ac33d4b 100644--- a/open-sse/services/compression/rules/es/structural.json+++ b/open-sse/services/compression/rules/es/structural.json@@ -25,6 +25,81 @@"context": "all","category": "structural","minIntensity": "lite"+ },+ {+ "name": "es_redundant_phrasing",+ "pattern": "\\b(?:asegurate de|asegúrate de|asegurate que|asegúrate que|ten cuidado de)\\b\\s*",+ "replacement": "asegura ",+ "context": "all",+ "category": "structural",+ "minIntensity": "full"+ },+ {+ "name": "es_redundant_because",+ "pattern": "\\b(?:debido a que|por la razon de que|por la razón de que|la razon es porque|la razón es porque)\\b\\s*",+ "replacement": "porque ",+ "context": "all",+ "category": "structural",+ "minIntensity": "full"+ },+ {+ "name": "es_redundant_directive",+ "pattern": "\\b(?:es importante que|deberias|deberías|recuerda que)\\b\\s*",+ "replacement": "",+ "context": "all",+ "category": "structural",+ "minIntensity": "full"+ },+ {+ "name": "es_list_conjunction",+ "pattern": ",\\s*y tambien\\s+|,\\s*y también\\s+|,\\s*asi como\\s+|,\\s*así como\\s+",+ "replacement": ", ",+ "context": "all",+ "category": "structural",+ "minIntensity": "full"+ },+ {+ "name": "es_redundant_quantifiers",+ "pattern": "\\b(?:cada uno de los|cada una de las|todos y cada uno|todas y cada una)\\b",+ "replacement": "cada",+ "context": "all",+ "category": "structural",+ "minIntensity": "full"+ },+ {+ "name": "es_all_quantifier",+ "pattern": "\\b(?:cualquiera y todos|todas y cada una de las|todos y cada uno de los)\\b",+ "replacement": "todos",+ "context": "all",+ "category": "structural",+ "minIntensity": "full"+ },+ {+ "name": "es_transition_removal",+ "pattern": "^(?:Por otro lado,?\\s*|En contraste,?\\s*|Sin embargo,?\\s*)",+ "replacement": "",+ "context": "all",+ "category": "structural",+ "minIntensity": "lite"+ },+ {+ "name": "es_passive_voice",+ "pattern": "\\b(?:esta siendo usado|está siendo usado|esta siendo llamada|está siendo llamada|esta siendo generado|está siendo generado|fue creado|fue generado|fue implementado)\\b",+ "replacement": "usa",+ "replacementMap": {+ "esta siendo usado": "usa",+ "está siendo usado": "usa",+ "esta siendo llamada": "llama",+ "está siendo llamada": "llama",+ "esta siendo generado": "generado",+ "está siendo generado": "generado",+ "fue creado": "creado",+ "fue generado": "generado",+ "fue implementado": "implementado"+ },+ "context": "all",+ "category": "structural",+ "minIntensity": "full"}]}diff --git a/open-sse/services/compression/rules/es/ultra.json b/open-sse/services/compression/rules/es/ultra.jsonnew file mode 100644index 0000000000..bbc51cd0c0--- /dev/null+++ b/open-sse/services/compression/rules/es/ultra.json@@ -0,0 +1,107 @@+{+ "language": "es",+ "category": "ultra",+ "rules": [+ {+ "name": "es_articles",+ "pattern": "\\b(?:[Ee]l|[Ll]a|[Ll]os|[Ll]as|[Uu]n|[Uu]na|[Uu]nos|[Uu]nas)\\s+(?=[a-záéíóúñ])",+ "flags": "g",+ "replacement": "",+ "context": "all",+ "category": "terse",+ "minIntensity": "full"+ },+ {+ "name": "es_leader_phrases",+ "pattern": "^(?:voy a|puedo|podemos|vamos a|dejame|déjame|se puede)\\s+(?=[a-záéíóúñ])",+ "replacement": "",+ "context": "all",+ "category": "terse",+ "minIntensity": "full"+ },+ {+ "name": "es_ultra_database_abbreviation",+ "pattern": "\\bbase de datos\\b",+ "replacement": "BD",+ "context": "all",+ "category": "ultra",+ "minIntensity": "ultra"+ },+ {+ "name": "es_ultra_config_abbreviation",+ "pattern": "\\bconfiguracion\\b|\\bconfiguración\\b",+ "replacement": "config",+ "context": "all",+ "category": "ultra",+ "minIntensity": "ultra"+ },+ {+ "name": "es_ultra_function_abbreviation",+ "pattern": "\\bfuncion\\b|\\bfunción\\b",+ "replacement": "fn",+ "context": "all",+ "category": "ultra",+ "minIntensity": "ultra"+ },+ {+ "name": "es_ultra_request_abbreviation",+ "pattern": "\\b(?:peticion|petición|solicitud)\\b",+ "replacement": "req",+ "context": "all",+ "category": "ultra",+ "minIntensity": "ultra"+ },+ {+ "name": "es_ultra_response_abbreviation",+ "pattern": "\\brespuesta\\b",+ "replacement": "res",+ "context": "all",+ "category": "ultra",+ "minIntensity": "ultra"+ },+ {+ "name": "es_ultra_implementation_abbreviation",+ "pattern": "\\bimplementacion\\b|\\bimplementación\\b",+ "replacement": "impl",+ "context": "all",+ "category": "ultra",+ "minIntensity": "ultra"+ },+ {+ "name": "es_ultra_authentication_abbreviation",+ "pattern": "\\bautenticacion\\b|\\bautenticación\\b",+ "replacement": "auth",+ "context": "all",+ "category": "ultra",+ "minIntensity": "ultra"+ },+ {+ "name": "es_ultra_authorization_abbreviation",+ "pattern": "\\bautorizacion\\b|\\bautorización\\b",+ "replacement": "authz",+ "context": "all",+ "category": "ultra",+ "minIntensity": "ultra"+ },+ {+ "name": "es_ultra_application_abbreviation",+ "pattern": "\\baplicacion\\b|\\baplicación\\b",+ "replacement": "app",+ "context": "all",+ "category": "ultra",+ "minIntensity": "ultra"+ },+ {+ "name": "es_ultra_dependency_abbreviation",+ "pattern": "\\b(?:dependencia|dependencias)\\b",+ "replacement": "dep",+ "replacementMap": {+ "dependencia": "dep",+ "dependencias": "deps"+ },+ "context": "all",+ "category": "ultra",+ "minIntensity": "ultra"+ }+ ]+}diff --git a/open-sse/services/compression/strategySelector.ts b/open-sse/services/compression/strategySelector.tsindex 37bc9782ce..49edd08419 100644--- a/open-sse/services/compression/strategySelector.ts+++ b/open-sse/services/compression/strategySelector.ts@@ -13,6 +13,7 @@ import { createCompressionStats } from "./stats.ts";import { registerBuiltinCompressionEngines } from "./engines/index.ts";import { getCompressionEngine } from "./engines/registry.ts";import { applyRtkCompression } from "./engines/rtk/index.ts";+import { adaptBodyForCompression } from "./bodyAdapter.ts";import {detectCachingContext,getCacheAwareStrategy,@@ -73,19 +74,23 @@ export function applyCompression(if (mode === "off") {return { body, compressed: false, stats: null };}- if (mode === "lite") {- return applyLiteCompression(body, {- ...options,- preserveSystemPrompt: options?.config?.preserveSystemPrompt !== false,- });- }if (mode === "rtk") {return applyRtkCompression(body, {config: options?.config?.rtkConfig,});}+ const adapter = adaptBodyForCompression(body);+ const compressionBody = adapter.body;+ if (mode === "lite") {+ const result = applyLiteCompression(compressionBody, {+ ...options,+ preserveSystemPrompt: options?.config?.preserveSystemPrompt !== false,+ });+ return adapter.adapted ? { ...result, body: adapter.restore(result.body) } : result;+ }if (mode === "stacked") {- return applyStackedCompression(body, options?.config?.stackedPipeline, options);+ const result = applyStackedCompression(compressionBody, options?.config?.stackedPipeline, options);+ return adapter.adapted ? { ...result, body: adapter.restore(result.body) } : result;}if (mode === "standard") {const cavemanConfig = {@@ -105,10 +110,14 @@ export function applyCompression(}: {}),};- return cavemanCompress(body as Parameters<typeof cavemanCompress>[0], cavemanConfig);+ const result = cavemanCompress(+ compressionBody as Parameters<typeof cavemanCompress>[0],+ cavemanConfig+ );+ return adapter.adapted ? { ...result, body: adapter.restore(result.body) } : result;}if (mode === "aggressive") {- const messages = (body.messages ?? []) as Array<{+ const messages = (compressionBody.messages ?? []) as Array<{role: string;content?: string | Array<{ type: string; text?: string }>;[key: string]: unknown;@@ -121,12 +130,12 @@ export function applyCompression(preserveSystemPrompt: options?.config?.preserveSystemPrompt !== false,};const result = compressAggressive(messages, aggressiveConfig);- const compressedBody = { ...body, messages: result.messages };+ const compressedBody = { ...compressionBody, messages: result.messages };return {- body: compressedBody,+ body: adapter.restore(compressedBody),compressed: result.stats.savingsPercent > 0,stats: createCompressionStats(- body,+ compressionBody,compressedBody,mode,["aggressive"],@@ -136,7 +145,7 @@ export function applyCompression(};}if (mode === "ultra") {- const messages = (body.messages ?? []) as Array<{+ const messages = (compressionBody.messages ?? []) as Array<{role: string;content?: string | unknown[];[key: string]: unknown;@@ -149,12 +158,12 @@ export function applyCompression(preserveSystemPrompt: options?.config?.preserveSystemPrompt !== false,};const result = ultraCompress(messages, ultraConfig);- const compressedBody = { ...body, messages: result.messages };+ const compressedBody = { ...compressionBody, messages: result.messages };return {- body: compressedBody,+ body: adapter.restore(compressedBody),compressed: result.stats.savingsPercent > 0,stats: createCompressionStats(- body,+ compressionBody,compressedBody,mode,["ultra"],diff --git a/src/lib/db/compressionAnalytics.ts b/src/lib/db/compressionAnalytics.tsindex 16a5b51415..fd84fe35b6 100644--- a/src/lib/db/compressionAnalytics.ts+++ b/src/lib/db/compressionAnalytics.ts@@ -26,6 +26,8 @@ export interface CompressionAnalyticsRow {output_mode?: string | null;rtk_raw_output_pointer?: string | null;rtk_raw_output_bytes?: number | null;+ rtk_raw_output_pointers?: string | null;+ rtk_raw_output_total_bytes?: number | null;}export interface CompressionAnalyticsSummary {@@ -118,6 +120,14 @@ function ensureCompressionAnalyticsColumns(): void {"rtk_raw_output_bytes","ALTER TABLE compression_analytics ADD COLUMN rtk_raw_output_bytes INTEGER");+ addColumn(+ "rtk_raw_output_pointers",+ "ALTER TABLE compression_analytics ADD COLUMN rtk_raw_output_pointers TEXT"+ );+ addColumn(+ "rtk_raw_output_total_bytes",+ "ALTER TABLE compression_analytics ADD COLUMN rtk_raw_output_total_bytes INTEGER"+ );columnsEnsuredForDb = db;}@@ -131,9 +141,10 @@ export function insertCompressionAnalyticsRow(row: CompressionAnalyticsRow): voiduration_ms, request_id, actual_prompt_tokens, actual_completion_tokens,actual_total_tokens, actual_cache_read_tokens, actual_cache_write_tokens,estimated_usd_saved, mcp_description_tokens_saved, multimodal_skip_count,- receipt_source, validation_fallback, output_mode, rtk_raw_output_pointer, rtk_raw_output_bytes+ receipt_source, validation_fallback, output_mode, rtk_raw_output_pointer, rtk_raw_output_bytes,+ rtk_raw_output_pointers, rtk_raw_output_total_bytes)- VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)+ VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(row.timestamp,@@ -159,7 +170,9 @@ export function insertCompressionAnalyticsRow(row: CompressionAnalyticsRow): voirow.validation_fallback ? 1 : 0,row.output_mode ?? null,row.rtk_raw_output_pointer ?? null,- row.rtk_raw_output_bytes ?? null+ row.rtk_raw_output_bytes ?? null,+ row.rtk_raw_output_pointers ?? null,+ row.rtk_raw_output_total_bytes ?? null);}diff --git a/tests/unit/compression/body-adapter.test.ts b/tests/unit/compression/body-adapter.test.tsnew file mode 100644index 0000000000..be584bf211--- /dev/null+++ b/tests/unit/compression/body-adapter.test.ts@@ -0,0 +1,189 @@+import { describe, it } from "node:test";+import assert from "node:assert/strict";++import { applyCompression } from "../../../open-sse/services/compression/strategySelector.ts";+import { applyRtkCompression } from "../../../open-sse/services/compression/engines/rtk/index.ts";++describe("compression body adapter", () => {+ it("applies Caveman compression to OpenAI Responses input messages", () => {+ const body = {+ model: "gpt-5.5-codex",+ input: [+ {+ type: "message",+ role: "user",+ content: [+ {+ type: "input_text",+ text: "Please could you provide a detailed explanation of this implementation? Thank you so much for your help!",+ },+ ],+ },+ {+ type: "function_call",+ call_id: "call_1",+ name: "read_file",+ arguments: "{}",+ },+ ],+ };++ const result = applyCompression(body, "standard", {+ config: {+ enabled: true,+ defaultMode: "standard",+ autoTriggerTokens: 0,+ cacheMinutes: 5,+ preserveSystemPrompt: true,+ comboOverrides: {},+ cavemanConfig: {+ enabled: true,+ compressRoles: ["user"],+ skipRules: [],+ minMessageLength: 10,+ preservePatterns: [],+ intensity: "full",+ },+ },+ });++ assert.equal(result.compressed, true);+ assert.ok(!("messages" in result.body), "Responses body must not leak synthetic messages");+ const input = result.body.input as typeof body.input;+ assert.equal(input[1], body.input[1], "non-message Responses items should be preserved");+ const text = input[0].content[0].text;+ assert.ok(!text.includes("Please could you"));+ assert.ok(!text.includes("Thank you so much"));+ assert.ok(text.includes("explain"));+ });++ it("applies RTK compression to Responses function_call_output items", () => {+ const repeatedOutput = Array.from({ length: 20 }, () => "same noisy line").join("\n");+ const body = {+ input: [+ {+ type: "function_call_output",+ call_id: "call_1",+ output: repeatedOutput,+ },+ ],+ };++ const result = applyRtkCompression(body);++ assert.equal(result.compressed, true);+ assert.ok(!("messages" in result.body), "Responses body must not leak synthetic messages");+ const input = result.body.input as typeof body.input;+ assert.match(input[0].output, /\[rtk:dropped/);+ assert.equal(input[0].call_id, "call_1");+ });++ it("restores compressed array output on Responses function_call_output items", () => {+ const repeatedOutput = Array.from({ length: 20 }, () => "same noisy line").join("\n");+ const body = {+ input: [+ {+ type: "function_call_output",+ call_id: "call_1",+ output: [{ type: "input_text", text: repeatedOutput }],+ },+ ],+ };++ const result = applyRtkCompression(body);+ const input = result.body.input as typeof body.input;++ assert.equal(result.compressed, true);+ assert.match(input[0].output[0].text, /\[rtk:dropped/);+ assert.ok(!("content" in input[0]), "function_call_output should keep canonical output field");+ });++ it("restores adapted Responses bodies even when no compression is applied", () => {+ const body = {+ input: [+ {+ type: "message",+ role: "user",+ content: [{ type: "input_text", text: "short" }],+ },+ ],+ };++ const result = applyCompression(body, "standard", {+ config: {+ enabled: true,+ defaultMode: "standard",+ autoTriggerTokens: 0,+ cacheMinutes: 5,+ preserveSystemPrompt: true,+ comboOverrides: {},+ cavemanConfig: {+ enabled: true,+ compressRoles: ["user"],+ skipRules: [],+ minMessageLength: 50,+ preservePatterns: [],+ intensity: "full",+ },+ },+ });++ assert.equal(result.compressed, false);+ assert.ok(!("messages" in result.body));+ assert.deepEqual(result.body.input, body.input);+ });++ it("does not misalign Responses input items if an engine removes a synthetic message", () => {+ const body = {+ input: [+ { type: "message", role: "user", content: "duplicate" },+ { type: "message", role: "user", content: "duplicate" },+ { type: "message", role: "user", content: "unique" },+ ],+ };++ const result = applyCompression(body, "lite", {+ config: {+ enabled: true,+ defaultMode: "lite",+ autoTriggerTokens: 0,+ cacheMinutes: 5,+ preserveSystemPrompt: true,+ comboOverrides: {},+ },+ });++ assert.equal(result.compressed, true);+ assert.deepEqual(result.body.input, body.input);+ });++ it("compresses string Responses input without converting the request shape", () => {+ const body = {+ input:+ "Please could you provide a detailed explanation of this implementation? Thank you so much for your help!",+ };++ const result = applyCompression(body, "standard", {+ config: {+ enabled: true,+ defaultMode: "standard",+ autoTriggerTokens: 0,+ cacheMinutes: 5,+ preserveSystemPrompt: true,+ comboOverrides: {},+ cavemanConfig: {+ enabled: true,+ compressRoles: ["user"],+ skipRules: [],+ minMessageLength: 10,+ preservePatterns: [],+ intensity: "full",+ },+ },+ });++ assert.equal(result.compressed, true);+ assert.equal(typeof result.body.input, "string");+ assert.ok(!(result.body.input as string).includes("Please could you"));+ });+});diff --git a/tests/unit/compression/compressionAnalytics.test.ts b/tests/unit/compression/compressionAnalytics.test.tsindex 12d1f55443..5f00962fbc 100644--- a/tests/unit/compression/compressionAnalytics.test.ts+++ b/tests/unit/compression/compressionAnalytics.test.ts@@ -89,6 +89,37 @@ describe("compressionAnalytics", () => {assert.equal(summary.totalRequests, 1);});+ it("stores all RTK raw output pointers when provided", () => {+ insertCompressionAnalyticsRow({+ timestamp: new Date().toISOString(),+ mode: "rtk",+ original_tokens: 1000,+ compressed_tokens: 500,+ tokens_saved: 500,+ rtk_raw_output_pointer: "raw_1",+ rtk_raw_output_bytes: 100,+ rtk_raw_output_pointers: JSON.stringify(["raw_1", "raw_2"]),+ rtk_raw_output_total_bytes: 250,+ });++ const db = getDbInstance();+ const row = db+ .prepare(+ "SELECT rtk_raw_output_pointer, rtk_raw_output_bytes, rtk_raw_output_pointers, rtk_raw_output_total_bytes FROM compression_analytics LIMIT 1"+ )+ .get() as {+ rtk_raw_output_pointer: string;+ rtk_raw_output_bytes: number;+ rtk_raw_output_pointers: string;+ rtk_raw_output_total_bytes: number;+ };++ assert.equal(row.rtk_raw_output_pointer, "raw_1");+ assert.equal(row.rtk_raw_output_bytes, 100);+ assert.equal(row.rtk_raw_output_pointers, JSON.stringify(["raw_1", "raw_2"]));+ assert.equal(row.rtk_raw_output_total_bytes, 250);+ });+it("summary counts correctly after multiple inserts", () => {insertCompressionAnalyticsRow({timestamp: new Date().toISOString(),diff --git a/tests/unit/compression/language-packs.test.ts b/tests/unit/compression/language-packs.test.tsindex b551e6bfff..7172f40374 100644--- a/tests/unit/compression/language-packs.test.ts+++ b/tests/unit/compression/language-packs.test.ts@@ -48,6 +48,28 @@ describe("Caveman language packs", () => {assert.ok(text.includes("auth"));});+ it("keeps the Spanish pack aligned with English rule categories", () => {+ const esRules = loadAllRulesForLanguage("es", { refresh: true });+ assert.ok(esRules.length >= 40, `es expected 40+ rules, got ${esRules.length}`);+ assert.ok(esRules.some((rule) => rule.category === "dedup"), "es missing dedup");+ assert.ok(esRules.some((rule) => rule.category === "ultra"), "es missing ultra");+ assert.ok(esRules.some((rule) => rule.category === "terse"), "es missing terse");+ });++ it("applies expanded Spanish rules without touching technical terms", () => {+ const esRules = getRulesForContext("user", "ultra", "es");+ const { text } = applyRulesToText(+ "Por favor proporciona una explicación detallada de la base de datos y autenticación en src/auth.ts",+ esRules+ );++ assert.ok(!text.toLowerCase().includes("por favor"));+ assert.ok(!text.toLowerCase().includes("explicación detallada"));+ assert.ok(text.includes("BD"));+ assert.ok(text.includes("auth"));+ assert.ok(text.includes("src/auth.ts"));+ });+it("builds localized output mode instructions", () => {const config = { enabled: true, intensity: "full" as const, autoClarity: true };diff --git a/tests/unit/compression/outputMode.test.ts b/tests/unit/compression/outputMode.test.tsindex 33de29d05e..fffcaa4d0c 100644--- a/tests/unit/compression/outputMode.test.ts+++ b/tests/unit/compression/outputMode.test.ts@@ -68,6 +68,17 @@ describe("Caveman output mode", () => {assert.equal(result.body.messages?.at(-1)?.content, body.messages[0].content);});+ it("uses Responses instructions when input has no messages", () => {+ const result = applyCavemanOutputMode(+ { input: [{ type: "message", role: "user", content: "Summarize logs." }] },+ { enabled: true, intensity: "full", autoClarity: true }+ );++ assert.equal(result.applied, true);+ assert.match(String(result.body.instructions), /Caveman Output Mode/);+ assert.ok(!("messages" in result.body));+ });+it("bypasses security, destructive, clarification, and order-sensitive prompts", () => {const cases = ["Explain this security vulnerability in detail.",diff --git a/tests/unit/compression/rtk-code-stripper.test.ts b/tests/unit/compression/rtk-code-stripper.test.tsindex ab28be648e..bba15c0264 100644--- a/tests/unit/compression/rtk-code-stripper.test.ts+++ b/tests/unit/compression/rtk-code-stripper.test.ts@@ -16,27 +16,24 @@ describe("RTK code stripper", () => {assert.equal(detectCodeLanguage("class Main { }"), "java");});- it("removes single-line and multi-line comments", () => {+ it("preserves comments and string literals safely", () => {const js = stripCode(- "// comment\nconst value = 1;\n/* block */\nconsole.log(value);",+ "// comment\nconst url = 'https://example.com/a//b';\n/* block */\nconsole.log(url);","javascript");- const py = stripCode('"""doc"""\n# comment\nprint("ok")', "python");- const rb = stripCode("=begin\ncomment\n=end\n# comment\nputs 'ok'", "ruby");- assert.ok(!js.text.includes("comment"));- assert.ok(!js.text.includes("block"));- assert.ok(!py.text.includes("doc"));- assert.ok(!rb.text.includes("comment"));+ assert.ok(js.text.includes("// comment"));+ assert.ok(js.text.includes("https://example.com/a//b"));+ assert.ok(js.text.includes("/* block */"));});- it("preserves docstrings when configured", () => {+ it("preserves Python docstrings and comments", () => {const result = stripCode('"""doc"""\n# comment\nprint("ok")', "python", {preserveDocstrings: true,});assert.ok(result.text.includes("doc"));- assert.ok(!result.text.includes("# comment"));+ assert.ok(result.text.includes("# comment"));});it("applies to fenced code blocks through RTK runtime", () => {@@ -44,7 +41,13 @@ describe("RTK code stripper", () => {messages: [{role: "assistant",- content: "```ts\n// remove\nconst value: number = 1;\n```\nDone.",+ content: `Before.++\`\`\`txt+${Array.from({ length: 20 }, () => "same code line").join("\n")}+\`\`\`++After.`,},],};@@ -65,8 +68,68 @@ describe("RTK code stripper", () => {assert.equal(result.compressed, true);const serialized = JSON.stringify(result.body.messages);- assert.match(serialized, /const value/);- assert.doesNotMatch(serialized, /remove/);+ assert.match(serialized, /Before/);+ assert.match(serialized, /After/);+ assert.match(serialized, /same code line/);+ assert.match(serialized, /\[rtk:dropped/);assert.ok(result.stats?.techniquesUsed.includes("rtk-code-strip"));});++ it("does not compress non-code text when only code block compression is enabled", () => {+ const content = Array.from({ length: 20 }, () => "same prose line").join("\n");+ const body = {+ messages: [{ role: "assistant", content }],+ };+ const result = applyRtkCompression(body, {+ config: {+ enabled: true,+ intensity: "standard",+ applyToToolResults: false,+ applyToAssistantMessages: false,+ applyToCodeBlocks: true,+ enabledFilters: [],+ disabledFilters: [],+ maxLinesPerResult: 100,+ maxCharsPerResult: 12000,+ deduplicateThreshold: 3,+ },+ });++ assert.equal(result.compressed, false);+ assert.deepEqual(result.body, body);+ });++ it("does not compress fenced code when code block compression is disabled", () => {+ const body = {+ messages: [+ {+ role: "assistant",+ content: `Before.++\`\`\`txt+${Array.from({ length: 20 }, () => "same code line").join("\n")}+\`\`\`++After.`,+ },+ ],+ };+ const result = applyRtkCompression(body, {+ config: {+ enabled: true,+ intensity: "standard",+ applyToToolResults: false,+ applyToAssistantMessages: false,+ applyToCodeBlocks: false,+ enabledFilters: [],+ disabledFilters: [],+ maxLinesPerResult: 100,+ maxCharsPerResult: 12000,+ deduplicateThreshold: 3,+ },+ });++ assert.equal(result.compressed, false);+ assert.deepEqual(result.body, body);+ });});