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
Merge release/v3.7.7 into compression phase 3
Antigravity Assistant5e0d6263ed32
diff --cc open-sse/handlers/chatCore.tsindex 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.tsindex 4c4d7f43a4,697a2de887..2b2f834a13--- a/open-sse/services/compression/index.ts+++ b/open-sse/services/compression/index.ts@@@ -5,23 -5,21 +5,30 @@@ export typeCompressionResult,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 @@@ exportcheckComboOverride,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.tsindex 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 applyCompressionreturn 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.tsindex 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 CavemanConfigpreservePatterns: 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.tsindex 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.tsindex 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.sqlindex 59abd68511,0000000000..bd9bf23647mode 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;