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
/**
* Pure model for the stacked-compression pipeline editor (T06 — gaps v3.8.42).
*
* Every operation returns a NEW `PipelineStep[]` (never mutates the input), preserves the
* engine→intensity invariant (a step's intensity is always one its engine allows), and keeps
* the pipeline non-empty — so the combos editor can never persist an invalid stacked
* pipeline that the `PUT /api/context/combos/[id]` route would reject. The React editor is a
* thin shell over these functions; the logic is tested in isolation.
*/
export type PipelineStep = { engine: string; intensity?: string };
export type EngineIntensities = Record<string, readonly string[]>;
const FALLBACK_INTENSITIES: readonly string[] = ["standard"];
/** Intensities a given engine allows (falls back to `["standard"]` for unknown engines). */
export function allowedIntensities(engine: string, table: EngineIntensities): readonly string[] {
const list = table[engine];
return list && list.length > 0 ? list : FALLBACK_INTENSITIES;
}
/** Coerce a step's intensity to one valid for its engine (first allowed when invalid). */
export function normalizeStep(step: PipelineStep, table: EngineIntensities): PipelineStep {
const allowed = allowedIntensities(step.engine, table);
return {
engine: step.engine,
intensity: allowed.includes(step.intensity ?? "") ? step.intensity : allowed[0],
};
}
/**
* Reorder: move the step at `from` to `to`. Out-of-range indices (or `from === to`) return a
* copy unchanged. The result is always a permutation of the input (same length, same members).
*/
export function moveLayer(steps: PipelineStep[], from: number, to: number): PipelineStep[] {
const next = steps.slice();
if (from === to) return next;
if (from < 0 || from >= steps.length || to < 0 || to >= steps.length) return next;
const [moved] = next.splice(from, 1);
next.splice(to, 0, moved);
return next;
}
/** Append a new layer (normalized for its engine). */
export function addLayer(
steps: PipelineStep[],
step: PipelineStep,
table: EngineIntensities
): PipelineStep[] {
return [...steps, normalizeStep(step, table)];
}
/** Remove the layer at `index`, never dropping below `minLength` (default 1). */
export function removeLayer(steps: PipelineStep[], index: number, minLength = 1): PipelineStep[] {
if (steps.length <= minLength) return steps.slice();
if (index < 0 || index >= steps.length) return steps.slice();
return steps.filter((_, i) => i !== index);
}
/** Patch the layer at `index`, re-normalizing intensity for the (possibly new) engine. */
export function updateLayer(
steps: PipelineStep[],
index: number,
patch: Partial<PipelineStep>,
table: EngineIntensities
): PipelineStep[] {
if (index < 0 || index >= steps.length) return steps.slice();
return steps.map((step, i) => (i === index ? normalizeStep({ ...step, ...patch }, table) : step));
}