@sema-agent/core/dist/core/runner/run-compaction-machinery.js

Stateless, task-oriented AI agent core

import { DEFAULT_COMPACTION_SETTINGS } from "../../internal/harness.js";
import { resolveTriggerWindow } from "../context-edit.js";
import { compactionEnabled, contextOverlayFor } from "../context-settings.js";
import { sanitizeCompactionSettings } from "../auto-compaction.js";
import { isModelPriced, modelCostToPricing } from "../pricing.js";
import { emitTrace } from "../trace.js";
import { runWithReasoningWireFacts, runWithStatusSink } from "../../brain/status-sink.js";
import { cacheFamilyOf, usageCostMicroUsd } from "./usage-accounting.js";
export function runCompactionMachinery(input) {
    const { spec, prepared, rs, stats, noteUnevaluablePriceTable, runner } = input;
    const recordCompactionUsage = (m, msg) => {
        const u = msg?.usage;
        if (!u)
            return;
        if (msg.usageMissing === true)
            stats.usageMissing = true;
        const fam = cacheFamilyOf(m);
        const price = runner.deps.pricing?.[m.id] ?? modelCostToPricing(m.cost);
        const priced = isModelPriced(m, runner.deps.pricing);
        if (!priced)
            rs.telemetry.unpricedSpend = true;
        noteUnevaluablePriceTable(price);
        const { totalInputTokens, uncachedInputTokens, costMicroUsd } = usageCostMicroUsd(fam, u, price);
        stats.tokens += u.totalTokens || 0;
        stats.promptTokens += uncachedInputTokens;
        stats.totalInputTokens += totalInputTokens;
        stats.cachedTokens += u.cacheRead || 0;
        stats.cacheWriteTokens += u.cacheWrite || 0;
        stats.outputTokens += u.output || 0;
        stats.costMicroUsd += costMicroUsd;
        stats.compactionMicroUsd = (stats.compactionMicroUsd ?? 0) + costMicroUsd;
        emitTrace(rs.telemetry.tracer, () => ({
            kind: "brain.call", version: 1, taskId: rs.telemetry.taskId, model: m.id, provider: m.provider,
            promptTokens: uncachedInputTokens, totalInputTokens, completionTokens: u.output || 0,
            cacheRead: u.cacheRead || 0, cacheWrite: u.cacheWrite || 0,
            latencyMs: 0, ...(priced ? { costMicroUsd } : {}), ...(typeof msg?.stopReason === "string" ? { stopReason: msg.stopReason } : {}), ts: Date.now(),
        }));
    };
    const compactionBrain = {
        stream: runner.deps.brain.stream,
        complete: async (m, c, o) => {
            const msg = await runWithStatusSink(() => { }, async () => await runWithReasoningWireFacts(() => { }, async () => runner.deps.brain.complete
                ? await runner.deps.brain.complete(m, c, o)
                : await (await Promise.resolve(runner.deps.brain.stream(m, c, o))).result()));
            recordCompactionUsage(m, msg);
            return msg;
        },
    };
    const legOverlay = () => contextOverlayFor(runner.deps.contextSettings, prepared.harness.getModelRef(), runner.deps);
    const withinTaskCompaction = () => compactionEnabled(spec.compaction?.enabled, legOverlay()) && (spec.compaction?.withinTask ?? true);
    const compactionBreaker = { failures: 0 };
    if (compactionEnabled(spec.compaction?.enabled, legOverlay())) {
        const prefixWindow = resolveTriggerWindow(prepared.model, legOverlay()).window;
        if (Number.isFinite(prefixWindow) && prefixWindow > 0) {
            const prefixSettings = sanitizeCompactionSettings({ ...DEFAULT_COMPACTION_SETTINGS, ...spec.compaction }, prefixWindow);
            const prefixCompactAt = prefixWindow - prefixSettings.reserveTokens;
            if (prepared.promptOverheadTokens >= prefixCompactAt) {
                runner.deps.onError?.(new Error(`compaction cannot help: the fixed request prefix (system prompt + tool schemas, ≈${prepared.promptOverheadTokens} tokens) ` +
                    `already meets or exceeds the compaction threshold (${prefixCompactAt} of a ${prefixWindow}-token window). ` +
                    `Compaction only shrinks conversation history, so this run will re-trigger or overflow regardless — ` +
                    `shrink the system prompt/tool surface or use a larger-window model.`), { phase: "config", sessionId: prepared.sessionId });
            }
        }
    }
    const windowSafetyOptions = (mainModel) => ({
        ...(rs.budget.maxCostMicroUsd !== undefined
            ? {
                fallbackBudget: {
                    spentMicroUsd: () => stats.costMicroUsd,
                    capMicroUsd: rs.budget.maxCostMicroUsd,
                    mainInputPer1M: (runner.deps.pricing?.[mainModel.id] ?? modelCostToPricing(mainModel.cost)).inputPer1M,
                },
            }
            : {}),
        onWindowSafety: (info) => {
            if (info.kind === "fallback") {
                emitTrace(rs.telemetry.tracer, () => ({
                    kind: "compaction.model_fallback",
                    version: 1,
                    taskId: rs.telemetry.taskId,
                    contentTokens: info.contentTokens,
                    headroomTokens: info.headroomTokens ?? 0,
                    truncationRatio: info.truncationRatio,
                    ...(info.estCostMicroUsd !== undefined ? { estCostMicroUsd: info.estCostMicroUsd } : {}),
                    ts: Date.now(),
                }));
            }
            else {
                emitTrace(rs.telemetry.tracer, () => ({
                    kind: "compaction.clamp_disclosure",
                    version: 1,
                    taskId: rs.telemetry.taskId,
                    truncationRatio: info.truncationRatio,
                    reason: info.reason ?? "tolerance",
                    ...(info.estCostMicroUsd !== undefined ? { estCostMicroUsd: info.estCostMicroUsd } : {}),
                    ts: Date.now(),
                }));
            }
        },
    });
    return { compactionBrain, withinTaskCompaction, compactionBreaker, windowSafetyOptions };
}