@sema-agent/core/dist/core/runner/compaction-seams.js

Stateless, task-oriented AI agent core

import { classicEventBase, dispatchClassic, observeClassic, stringMembersAnswer, stringMembersOf } from "../mods/stations.js";
export function seamCCompactionOptions(runner, prepared) {
    return {
        ...(runner.deps.summaryProvider
            ? {
                summaryProvider: runner.deps.summaryProvider,
                onCompaction: runner.deps.onCompaction,
                maxConsecutiveProviderReuse: runner.deps.maxConsecutiveProviderReuse,
                consecutiveProviderReuse: prepared.compactionReuseRef.consecutive,
            }
            : {}),
        onCommitted: (effect) => {
            if (prepared.frameSettlement.wantsEffects?.() !== true)
                return;
            prepared.frameSettlement.compactions.push(effect);
        },
    };
}
export function compactionHookOptions(runner, prepared, trigger, signal) {
    const bus = prepared.modBus;
    const base = classicEventBase(prepared.hookIdentity);
    const report = (err) => {
        try {
            runner.deps.onError?.(err, { phase: "hook", sessionId: prepared.sessionId });
        }
        catch {
        }
    };
    return {
        trigger,
        ...(bus.hasHandlers("classic.PreCompact")
            ? {
                preCompact: async (ctx) => {
                    const outcome = await dispatchClassic(bus, "classic.PreCompact", { ...base, trigger: ctx.trigger, ...(ctx.customInstructions !== undefined ? { customInstructions: ctx.customInstructions } : {}) }, { ...(signal !== undefined ? { signal } : {}), checkAnswer: stringMembersAnswer("classic.PreCompact", ["block", "additionalInstructions"]) });
                    if (outcome?.kind !== "answered")
                        return undefined;
                    const r = stringMembersOf(outcome.answer, ["block", "additionalInstructions"]);
                    if (r.block && ctx.trigger === "forced") {
                        report(new Error(`a preCompact handler blocked a "forced" compaction — ignored (PTL/trim-pressure compaction is not optional): ${r.block}`));
                    }
                    return r;
                },
            }
            : {}),
        ...(bus.hasHandlers("classic.PostCompact")
            ? {
                postCompact: (ctx) => observeClassic(bus, "classic.PostCompact", {
                    ...base,
                    trigger: ctx.trigger,
                    summary: ctx.summary,
                    ...(ctx.tokensBefore !== undefined ? { tokensBefore: ctx.tokensBefore } : {}),
                    ...(ctx.tokensAfter !== undefined ? { tokensAfter: ctx.tokensAfter } : {}),
                    ...(ctx.freedTokens !== undefined ? { freedTokens: ctx.freedTokens } : {}),
                }, signal),
            }
            : {}),
    };
}
export function recordCompactionReuse(runner, prepared, comp) {
    if (!runner.deps.summaryProvider || !comp.compacted)
        return;
    prepared.compactionReuseRef.consecutive = comp.reused ? prepared.compactionReuseRef.consecutive + 1 : 0;
}