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
import type { CompressionStats } from "./types.ts";
export type EngineBreakdownEntry = NonNullable<CompressionStats["engineBreakdown"]>[number];
/**
* Return a non-empty per-engine breakdown for the live `compression.completed` event.
*
* Only the stacked pipeline fills `stats.engineBreakdown`; single-engine modes
* (rtk/lite/standard/aggressive/ultra) leave it empty, which makes the dashboard studio render
* an empty Input→Output pipeline (no engine node, inert replay) for the most common case. When
* the breakdown is empty we synthesize a single entry from the overall stats so the studio
* always shows at least one real engine node. Mirrors `seedLatestCompressionRunFromDb`.
*/
export function ensureEngineBreakdown(stats: CompressionStats): EngineBreakdownEntry[] {
if (stats.engineBreakdown && stats.engineBreakdown.length > 0) {
return stats.engineBreakdown;
}
return [
{
engine: stats.engine || stats.mode || "compression",
originalTokens: stats.originalTokens,
compressedTokens: stats.compressedTokens,
savingsPercent: stats.savingsPercent,
techniquesUsed: stats.techniquesUsed ?? [],
...(stats.rulesApplied ? { rulesApplied: stats.rulesApplied } : {}),
...(stats.durationMs !== undefined ? { durationMs: stats.durationMs } : {}),
},
];
}
/**
* #6488 — Reconcile the single-engine breakdown entry's token counts with the response's
* authoritative outer counts.
*
* The outer `originalTokens`/`compressedTokens` fields (computed by the API route with a real
* tiktoken-based counter over the extracted message text) and each `engineBreakdown[]` entry's
* `originalTokens`/`compressedTokens` (computed internally by `estimateCompressionTokens`, a
* crude `JSON.stringify(requestBody).length / 4` estimate over the whole request-body object)
* use two different, unreconciled token-counting methodologies. They diverge most on
* small/degenerate inputs where JSON structural overhead (braces, quotes, `role`/`content`
* keys) dominates the char count.
*
* When the breakdown has exactly one entry, that entry represents the *same* before/after
* transformation as the overall response (single-engine dispatch, or a 1-step pipeline) — so
* its counts are safe to overwrite with the outer, more accurate figures. Multi-step
* breakdowns are left untouched: each intermediate step legitimately operates on the previous
* step's (already-compressed) output, so its "before" state is not the overall original input
* and reconciling it against the overall counts would be incorrect.
*/
export function reconcileSingleEngineTokens(
breakdown: EngineBreakdownEntry[],
outerOriginalTokens: number,
outerCompressedTokens: number,
outerSavingsPercent: number
): EngineBreakdownEntry[] {
if (breakdown.length !== 1) return breakdown;
const [entry] = breakdown;
return [
{
...entry,
originalTokens: outerOriginalTokens,
compressedTokens: outerCompressedTokens,
savingsPercent: outerSavingsPercent,
},
];
}