Skip to content

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

Merge release/v3.7.7 into compression phase 3

Antigravity Assistant5e0d6263ed32
diff --cc open-sse/handlers/chatCore.ts
index 5bb6cbe288,2cda405b4e..95c0406d72
--- a/open-sse/handlers/chatCore.ts
+++ b/open-sse/handlers/chatCore.ts
@@@ -106,12 -126,12 +126,6 @@@ import
} from "../services/modelFamilyFallback.ts";
import { computeRequestHash, deduplicate, shouldDeduplicate } from "../services/requestDedup.ts";
import { compressContext, estimateTokens, getTokenLimit } from "../services/contextManager.ts";
--import {
-- selectCompressionStrategy,
-- applyCompression,
--} from "../services/compression/strategySelector.ts";
--import { estimateCompressionTokens } from "../services/compression/stats.ts";
--import { getCompressionSettings } from "../../src/lib/db/compression.ts";
import {
getBackgroundTaskReason,
getDegradedModel,
@@@ -1227,6 -1567,37 +1561,37 @@@ export async function handleChatCore(
body?.messages || body?.input || body?.contents || body?.request?.contents || [];
if (body && Array.isArray(allMessages) && allMessages.length > 0) {
let estimatedTokens = estimateTokens(JSON.stringify(allMessages));
+
- // --- Modular Compression Pipeline (Phase 1 Lite + Phase 2 Standard/Caveman) ---
++ // --- Modular Compression Pipeline (Phase 1 Lite + Phase 2 Standard/Caveman + Phase 3 Aggressive) ---
+ // Runs BEFORE the existing reactive compressContext() to proactively reduce tokens.
+ try {
+ const { getCompressionSettings } = await import("../../src/lib/db/compression.ts");
+ const { selectCompressionStrategy, applyCompression } =
+ await import("../services/compression/strategySelector.ts");
+ const { trackCompressionStats } = await import("../services/compression/stats.ts");
+ const config = await getCompressionSettings();
+ const mode = selectCompressionStrategy(config, comboName ?? null, estimatedTokens);
+ if (mode !== "off") {
+ const result = applyCompression(body, mode, { model: effectiveModel, config });
+ if (result.compressed && result.stats) {
+ body = result.body as typeof body;
+ estimatedTokens = result.stats.compressedTokens;
+ trackCompressionStats(result.stats);
+ log?.info?.(
+ "COMPRESSION",
+ `Prompt compressed (${mode}): ${result.stats.originalTokens} -> ${result.stats.compressedTokens} tokens (${result.stats.savingsPercent}% saved, techniques: ${result.stats.techniquesUsed.join(",")})`
+ );
+ }
+ }
+ } catch (err) {
+ log?.warn?.(
+ "COMPRESSION",
+ "Compression pipeline error (non-fatal): " +
+ (err instanceof Error ? err.message : String(err))
+ );
+ }
+ // --- End Modular Compression Pipeline ---
+
let contextLimit = getTokenLimit(provider, effectiveModel);
if (isCombo && comboName) {
@@@ -1268,32 -1642,31 +1636,6 @@@
`Checking compression: ${estimatedTokens} tokens vs ${threshold} threshold (${contextLimit} limit, ${reservedTokens} reserved)`
);
-- // Prompt compression pipeline — Phase 1 (lite) + Phase 2 (standard/caveman)
-- try {
-- const compressionConfig = getCompressionSettings();
- estimatedTokens = estimateCompressionTokens(body);
- const estimatedTokens = estimateCompressionTokens(body);
-- const mode = selectCompressionStrategy(compressionConfig, comboName ?? null, estimatedTokens);
-- if (mode !== "off") {
-- const compressionResult = applyCompression(body as Record<string, unknown>, mode, {
-- model: effectiveModel,
-- config: compressionConfig,
-- });
-- if (compressionResult.compressed && compressionResult.stats) {
-- body = compressionResult.body as typeof body;
-- const s = compressionResult.stats;
- estimatedTokens = s.compressedTokens;
-- log?.info?.(
-- "COMPRESSION",
-- `Prompt compression (${s.mode}): ${s.originalTokens} → ${s.compressedTokens} tokens (${s.savingsPercent}% savings, ${s.durationMs ?? 0}ms${
-- s.rulesApplied?.length ? `, rules: ${s.rulesApplied.join(", ")}` : ""
-- })`
-- );
-- }
-- }
-- } catch (err) {
-- log?.warn?.("COMPRESSION", "Prompt compression failed (non-fatal): " + err);
-- }
--
if (estimatedTokens > threshold) {
log?.info?.(
"CONTEXT",
diff --cc open-sse/services/compression/index.ts
index 4c4d7f43a4,697a2de887..2b2f834a13
--- a/open-sse/services/compression/index.ts
+++ b/open-sse/services/compression/index.ts
@@@ -5,23 -5,21 +5,30 @@@ export type
CompressionResult,
CavemanConfig,
CavemanRule,
+ AggressiveConfig,
+ AgingThresholds,
+ ToolStrategiesConfig,
+ SummarizerOpts,
+ Summarizer,
} from "./types.ts";
-export { DEFAULT_COMPRESSION_CONFIG, DEFAULT_CAVEMAN_CONFIG } from "./types.ts";
+export {
+ DEFAULT_COMPRESSION_CONFIG,
+ DEFAULT_CAVEMAN_CONFIG,
+ DEFAULT_AGGRESSIVE_CONFIG,
+} from "./types.ts";
- export { cavemanCompress, applyRulesToText } from "./caveman.ts";
+ export {
+ applyLiteCompression,
+ collapseWhitespace,
+ dedupSystemPrompt,
+ compressToolResults,
+ removeRedundantContent,
+ replaceImageUrls,
+ } from "./lite.ts";
+ export { cavemanCompress, applyRulesToText } from "./caveman.ts";
export { getRulesForContext, CAVEMAN_RULES } from "./cavemanRules.ts";
-
export { extractPreservedBlocks, restorePreservedBlocks } from "./preservation.ts";
export {
@@@ -38,14 -36,3 +45,12 @@@ export
checkComboOverride,
shouldAutoTrigger,
} from "./strategySelector.ts";
+
- export { applyLiteCompression } from "./lite.ts";
-
+export { RuleBasedSummarizer, createSummarizer } from "./summarizer.ts";
+
+export { compressToolResult } from "./toolResultCompressor.ts";
+export type { CompressionResult as ToolCompressionResult } from "./toolResultCompressor.ts";
+
+export { applyAging } from "./progressiveAging.ts";
+
+export { compressAggressive } from "./aggressive.ts";
diff --cc open-sse/services/compression/strategySelector.ts
index 0610c3874a,99da6340b9..c0092355a3
--- a/open-sse/services/compression/strategySelector.ts
+++ b/open-sse/services/compression/strategySelector.ts
@@@ -50,28 -49,10 +50,27 @@@ export function applyCompression
return applyLiteCompression(body, options);
}
if (mode === "standard") {
- const cavemanConfig = options?.config?.cavemanConfig;
- if (cavemanConfig) {
- return cavemanCompress(body as Parameters<typeof cavemanCompress>[0], cavemanConfig);
- }
- return { body, compressed: false, stats: null };
+ return cavemanCompress(
+ body as Parameters<typeof cavemanCompress>[0],
+ options?.config?.cavemanConfig
+ );
}
+ if (mode === "aggressive") {
+ const messages = (body.messages ?? []) as Array<{
+ role: string;
+ content?: string | Array<{ type: string; text?: string }>;
+ [key: string]: unknown;
+ }>;
+ if (!Array.isArray(messages) || messages.length === 0) {
+ return { body, compressed: false, stats: null };
+ }
+ const aggressiveConfig = options?.config?.aggressive;
+ const result = compressAggressive(messages, aggressiveConfig);
+ return {
+ body: { ...body, messages: result.messages },
+ compressed: result.stats.savingsPercent > 0,
+ stats: result.stats,
+ };
+ }
return { body, compressed: false, stats: null };
}
diff --cc open-sse/services/compression/types.ts
index c5ae929729,98b1446ca3..64007a0b5c
--- a/open-sse/services/compression/types.ts
+++ b/open-sse/services/compression/types.ts
@@@ -1,16 -1,11 +1,14 @@@
/**
- * Compression Pipeline Types — Phase 1 (Lite) + Phase 2 (Standard/Caveman)
+ * Compression Pipeline Types — Phase 1 (Lite) + Phase 2 (Standard/Caveman) + Phase 3 (Aggressive)
*
* Shared type definitions for the compression pipeline.
+ * Phase 1: 'off' and 'lite' modes.
+ * Phase 2: 'standard' mode (caveman engine).
+ * Phase 3: 'aggressive' mode (summarization + tool compression + aging).
*/
- /** Compression mode levels */
export type CompressionMode = "off" | "lite" | "standard" | "aggressive" | "ultra";
- /** A single caveman compression rule (Phase 2) */
export interface CavemanRule {
name: string;
pattern: RegExp;
@@@ -28,7 -22,16 +25,17 @@@ export interface CavemanConfig
preservePatterns: string[];
}
- /** Per-request compression statistics */
+ export interface CompressionConfig {
+ enabled: boolean;
+ defaultMode: CompressionMode;
+ autoTriggerTokens: number;
+ cacheMinutes: number;
+ preserveSystemPrompt: boolean;
+ comboOverrides: Record<string, CompressionMode>;
+ cavemanConfig?: CavemanConfig;
++ aggressive?: AggressiveConfig;
+ }
+
export interface CompressionStats {
originalTokens: number;
compressedTokens: number;
@@@ -38,14 -41,8 +45,13 @@@
timestamp: number;
rulesApplied?: string[];
durationMs?: number;
+ aggressive?: {
+ summarizerSavings: number;
+ toolResultSavings: number;
+ agingSavings: number;
+ };
}
- /** Result of a compression operation */
export interface CompressionResult {
body: Record<string, unknown>;
compressed: boolean;
diff --cc src/app/api/settings/compression/route.ts
index da40c7028f,c0a5793f46..aac876c355
--- a/src/app/api/settings/compression/route.ts
+++ b/src/app/api/settings/compression/route.ts
@@@ -1,61 -1,43 +1,69 @@@
- import { NextResponse } from "next/server";
+ import { NextRequest, NextResponse } from "next/server";
+ import { z } from "zod";
import { getCompressionSettings, updateCompressionSettings } from "@/lib/db/compression";
+ import { isAuthenticated } from "@/shared/utils/apiAuth";
import { isValidationFailure, validateBody } from "@/shared/validation/helpers";
- import { z } from "zod";
- const compressionModeValues = ["off", "lite", "standard", "aggressive", "ultra"] as const;
+ const compressionModeSchema = z.enum(["off", "lite", "standard", "aggressive", "ultra"]);
- const cavemanConfigSchema = z.object({
- enabled: z.boolean().optional(),
- compressRoles: z.array(z.enum(["user", "assistant", "system"])).optional(),
- skipRules: z.array(z.string()).optional(),
- minMessageLength: z.number().min(0).optional(),
- preservePatterns: z.array(z.string()).optional(),
- });
+ const cavemanConfigSchema = z
+ .object({
+ enabled: z.boolean().optional(),
+ compressRoles: z.array(z.enum(["user", "assistant", "system"])).optional(),
+ skipRules: z.array(z.string()).optional(),
+ minMessageLength: z.number().int().min(0).optional(),
+ preservePatterns: z.array(z.string()).optional(),
+ })
+ .strict();
+const aggressiveConfigSchema = z
+ .object({
+ thresholds: z
+ .object({
+ fullSummary: z.number().int().min(1).max(100).optional(),
+ moderate: z.number().int().min(1).max(100).optional(),
+ light: z.number().int().min(1).max(100).optional(),
+ verbatim: z.number().int().min(1).max(100).optional(),
+ })
+ .optional(),
+ toolStrategies: z
+ .object({
+ fileContent: z.boolean().optional(),
+ grepSearch: z.boolean().optional(),
+ shellOutput: z.boolean().optional(),
+ json: z.boolean().optional(),
+ errorMessage: z.boolean().optional(),
+ })
+ .optional(),
+ summarizerEnabled: z.boolean().optional(),
+ maxTokensPerMessage: z.number().int().min(256).max(32768).optional(),
+ minSavingsThreshold: z.number().min(0).max(1).optional(),
+ })
- .optional();
++ .strict();
+
- const updateCompressionSchema = z.object({
- enabled: z.boolean().optional(),
- defaultMode: z.enum(compressionModeValues).optional(),
- autoTriggerTokens: z.number().min(0).optional(),
- cacheMinutes: z.number().min(0).optional(),
- preserveSystemPrompt: z.boolean().optional(),
- comboOverrides: z.record(z.string(), z.enum(compressionModeValues)).optional(),
- cavemanConfig: cavemanConfigSchema.optional(),
- aggressive: aggressiveConfigSchema,
- });
+ const compressionSettingsUpdateSchema = z
+ .object({
+ enabled: z.boolean().optional(),
+ defaultMode: compressionModeSchema.optional(),
+ autoTriggerTokens: z.number().int().min(0).optional(),
+ cacheMinutes: z.number().int().min(1).max(60).optional(),
+ preserveSystemPrompt: z.boolean().optional(),
+ comboOverrides: z.record(z.string(), compressionModeSchema).optional(),
+ cavemanConfig: cavemanConfigSchema.optional(),
++ aggressive: aggressiveConfigSchema.optional(),
+ })
+ .strict();
+
+ export async function GET(request: NextRequest) {
+ if (!(await isAuthenticated(request))) {
+ return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+ }
- export async function GET() {
try {
- const config = getCompressionSettings();
- return NextResponse.json(config);
+ const settings = await getCompressionSettings();
+ return NextResponse.json(settings);
} catch (error) {
- console.error("Error reading compression config:", error);
- return NextResponse.json({ error: "Failed to read compression config" }, { status: 500 });
+ return NextResponse.json({ error: String(error) }, { status: 500 });
}
}
diff --cc src/lib/db/compression.ts
index 2085090a29,9f3e43b899..8c4baa24ad
--- a/src/lib/db/compression.ts
+++ b/src/lib/db/compression.ts
@@@ -1,18 -1,22 +1,24 @@@
- import { getDbInstance } from "./core.ts";
- import { invalidateDbCache } from "./readCache.ts";
+ import { backupDbFile } from "./backup";
+ import { getDbInstance } from "./core";
+ import { invalidateDbCache } from "./readCache";
import {
- DEFAULT_COMPRESSION_CONFIG,
DEFAULT_CAVEMAN_CONFIG,
+ DEFAULT_AGGRESSIVE_CONFIG,
- } from "../../../open-sse/services/compression/types.ts";
- import type {
- CompressionConfig,
- CavemanConfig,
- CompressionMode,
- AggressiveConfig,
- } from "../../../open-sse/services/compression/types.ts";
+ DEFAULT_COMPRESSION_CONFIG,
++ type AggressiveConfig,
+ type CavemanConfig,
+ type CompressionConfig,
+ type CompressionMode,
+ } from "@omniroute/open-sse/services/compression/types.ts";
const NAMESPACE = "compression";
+ const COMPRESSION_MODES = new Set<CompressionMode>([
+ "off",
+ "lite",
+ "standard",
+ "aggressive",
+ "ultra",
+ ]);
type JsonRecord = Record<string, unknown>;
@@@ -29,13 -33,37 +35,117 @@@ function parseJsonSafe(raw: string | nu
}
}
- export function getCompressionSettings(): CompressionConfig {
+ function normalizeCavemanConfig(value: unknown): CavemanConfig {
+ const record = toRecord(value);
+ return {
+ ...DEFAULT_CAVEMAN_CONFIG,
+ ...record,
+ compressRoles: Array.isArray(record.compressRoles)
+ ? record.compressRoles.filter(
+ (role): role is "user" | "assistant" | "system" =>
+ role === "user" || role === "assistant" || role === "system"
+ )
+ : DEFAULT_CAVEMAN_CONFIG.compressRoles,
+ skipRules: Array.isArray(record.skipRules)
+ ? record.skipRules.filter((rule): rule is string => typeof rule === "string")
+ : DEFAULT_CAVEMAN_CONFIG.skipRules,
+ minMessageLength:
+ typeof record.minMessageLength === "number" && Number.isFinite(record.minMessageLength)
+ ? Math.max(0, Math.floor(record.minMessageLength))
+ : DEFAULT_CAVEMAN_CONFIG.minMessageLength,
+ preservePatterns: Array.isArray(record.preservePatterns)
+ ? record.preservePatterns.filter((pattern): pattern is string => typeof pattern === "string")
+ : DEFAULT_CAVEMAN_CONFIG.preservePatterns,
+ };
+ }
+
++function boundedInt(value: unknown, fallback: number, min: number, max: number): number {
++ if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
++ return Math.min(max, Math.max(min, Math.floor(value)));
++}
++
++function boundedNumber(value: unknown, fallback: number, min: number, max: number): number {
++ if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
++ return Math.min(max, Math.max(min, value));
++}
++
++function normalizeAggressiveConfig(value: unknown): AggressiveConfig {
++ const record = toRecord(value);
++ const thresholds = toRecord(record.thresholds);
++ const toolStrategies = toRecord(record.toolStrategies);
++
++ return {
++ ...DEFAULT_AGGRESSIVE_CONFIG,
++ thresholds: {
++ fullSummary: boundedInt(
++ thresholds.fullSummary,
++ DEFAULT_AGGRESSIVE_CONFIG.thresholds.fullSummary,
++ 1,
++ 100
++ ),
++ moderate: boundedInt(
++ thresholds.moderate,
++ DEFAULT_AGGRESSIVE_CONFIG.thresholds.moderate,
++ 1,
++ 100
++ ),
++ light: boundedInt(thresholds.light, DEFAULT_AGGRESSIVE_CONFIG.thresholds.light, 1, 100),
++ verbatim: boundedInt(
++ thresholds.verbatim,
++ DEFAULT_AGGRESSIVE_CONFIG.thresholds.verbatim,
++ 1,
++ 100
++ ),
++ },
++ toolStrategies: {
++ fileContent:
++ typeof toolStrategies.fileContent === "boolean"
++ ? toolStrategies.fileContent
++ : DEFAULT_AGGRESSIVE_CONFIG.toolStrategies.fileContent,
++ grepSearch:
++ typeof toolStrategies.grepSearch === "boolean"
++ ? toolStrategies.grepSearch
++ : DEFAULT_AGGRESSIVE_CONFIG.toolStrategies.grepSearch,
++ shellOutput:
++ typeof toolStrategies.shellOutput === "boolean"
++ ? toolStrategies.shellOutput
++ : DEFAULT_AGGRESSIVE_CONFIG.toolStrategies.shellOutput,
++ json:
++ typeof toolStrategies.json === "boolean"
++ ? toolStrategies.json
++ : DEFAULT_AGGRESSIVE_CONFIG.toolStrategies.json,
++ errorMessage:
++ typeof toolStrategies.errorMessage === "boolean"
++ ? toolStrategies.errorMessage
++ : DEFAULT_AGGRESSIVE_CONFIG.toolStrategies.errorMessage,
++ },
++ summarizerEnabled:
++ typeof record.summarizerEnabled === "boolean"
++ ? record.summarizerEnabled
++ : DEFAULT_AGGRESSIVE_CONFIG.summarizerEnabled,
++ maxTokensPerMessage: boundedInt(
++ record.maxTokensPerMessage,
++ DEFAULT_AGGRESSIVE_CONFIG.maxTokensPerMessage,
++ 256,
++ 32768
++ ),
++ minSavingsThreshold: boundedNumber(
++ record.minSavingsThreshold,
++ DEFAULT_AGGRESSIVE_CONFIG.minSavingsThreshold,
++ 0,
++ 1
++ ),
++ };
++}
++
+ export async function getCompressionSettings(): Promise<CompressionConfig> {
const db = getDbInstance();
const rows = db.prepare("SELECT key, value FROM key_value WHERE namespace = ?").all(NAMESPACE);
const config: CompressionConfig = {
...DEFAULT_COMPRESSION_CONFIG,
cavemanConfig: { ...DEFAULT_CAVEMAN_CONFIG },
++ aggressive: normalizeAggressiveConfig(undefined),
};
for (const row of rows) {
@@@ -70,33 -110,8 +192,12 @@@
}
break;
case "cavemanConfig":
- if (typeof parsed === "object" && parsed !== null) {
- config.cavemanConfig = {
- ...DEFAULT_CAVEMAN_CONFIG,
- ...(parsed as Partial<CavemanConfig>),
- };
- }
+ config.cavemanConfig = normalizeCavemanConfig(parsed);
break;
++ case "aggressive":
+ case "aggressiveConfig":
- if (typeof parsed === "object" && parsed !== null) {
- config.aggressive = {
- ...DEFAULT_AGGRESSIVE_CONFIG,
- ...(parsed as Partial<AggressiveConfig>),
- thresholds: {
- ...DEFAULT_AGGRESSIVE_CONFIG.thresholds,
- ...(((parsed as Record<string, unknown>).thresholds as Partial<
- typeof DEFAULT_AGGRESSIVE_CONFIG.thresholds
- >) ?? {}),
- },
- toolStrategies: {
- ...DEFAULT_AGGRESSIVE_CONFIG.toolStrategies,
- ...(((parsed as Record<string, unknown>).toolStrategies as Partial<
- typeof DEFAULT_AGGRESSIVE_CONFIG.toolStrategies
- >) ?? {}),
- },
- };
- }
++ config.aggressive = normalizeAggressiveConfig(parsed);
+ break;
}
}
@@@ -115,14 -133,8 +219,16 @@@ export async function updateCompression
}
});
- transaction();
+ tx();
+ backupDbFile("pre-write");
invalidateDbCache();
+ return getCompressionSettings();
}
+
+export function getDefaultAggressiveConfig(): AggressiveConfig {
+ return {
+ ...DEFAULT_AGGRESSIVE_CONFIG,
+ thresholds: { ...DEFAULT_AGGRESSIVE_CONFIG.thresholds },
+ toolStrategies: { ...DEFAULT_AGGRESSIVE_CONFIG.toolStrategies },
+ };
+}
diff --cc src/lib/db/migrations/036_aggressive_compression.sql
index 59abd68511,0000000000..bd9bf23647
mode 100644,000000..100644
--- a/src/lib/db/migrations/036_aggressive_compression.sql
+++ b/src/lib/db/migrations/036_aggressive_compression.sql
@@@ -1,4 -1,0 +1,4 @@@
- -- 031: Aggressive compression config
- -- Aggressive config is stored as a kv key in key_value(namespace='compression', key='aggressiveConfig')
++-- 036: Aggressive compression config
++-- Aggressive config is stored as a kv key in key_value(namespace='compression', key='aggressive')
+-- No schema change needed; this migration registers the version in _omniroute_migrations
- SELECT 1;
++SELECT 1;