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

Stateless, task-oriented AI agent core

import { composePostureFrames, owedPostureRow, postureStandingOf } from "../auto-mode-directive.js";
import { PRESENT_PLAN_TOOL_NAME } from "../present-plan-tool.js";
import { mintSystemReminder } from "../reminder-mint.js";
import { thrownText } from "../thrown-value.js";
import { rosterEntryNamed } from "../tool-roster.js";
import { sanitizeUntrustedText } from "../untrusted-text.js";
import { gitRestateOption } from "./git-leg-delivery.js";
import { attachmentEnvelopeTags } from "./turn-attachments.js";
export function postureFactsOf(prepared) {
    return {
        mode: prepared.approvalPosture.mode,
        askEffective: prepared.approvalPosture.askEffective,
        exitToolMounted: rosterEntryNamed(prepared.toolRoster, PRESENT_PLAN_TOOL_NAME) !== undefined,
        isChildLeg: prepared.hookIdentity.isDelegatedChild,
    };
}
export async function owedPostureText(prepared, ask) {
    const facts = postureFactsOf(prepared);
    const owed = owedPostureRow(facts) ?? null;
    const ref = prepared.postureFrameRef;
    if (ask === "on_change" && ref.composedFor === owed && owed?.cadence === undefined)
        return undefined;
    let messages = [];
    let read = true;
    try {
        messages = (await prepared.session.buildContext()).messages;
    }
    catch {
        read = false;
    }
    ref.composedFor = read ? owed : undefined;
    const frames = composePostureFrames(facts, postureStandingOf(messages, prepared.reminderMark));
    if (frames.length === 0)
        return undefined;
    const text = frames.map((frame) => mintSystemReminder(frame, prepared.reminderMark)).join("\n");
    ref.protectedText = text;
    return text;
}
export function postureRestateOption(prepared) {
    if (owedPostureRow(postureFactsOf(prepared)) === undefined)
        return {};
    return {
        postureRestate: () => appendOwedPosture(prepared, "always"),
    };
}
export async function appendOwedPosture(prepared, ask) {
    const ref = prepared.postureFrameRef;
    const text = await owedPostureText(prepared, ask);
    if (text === undefined) {
        if (ref.composedFor !== undefined)
            ref.unwritten = undefined;
        return;
    }
    const unwritten = () => {
        ref.composedFor = undefined;
        ref.unwritten = text;
    };
    if (prepared.batchHaltRef.current !== undefined)
        return unwritten();
    try {
        await prepared.session.appendMessage({ role: "user", content: [{ type: "text", text }], timestamp: Date.now(), engineMinted: true });
        ref.unwritten = undefined;
    }
    catch (err) {
        unwritten();
        try {
            ref.report?.(new Error(`permission posture frames could not be written to the transcript (stated on the next request's view only; the next boundary writes them): ${thrownText(err)}`));
        }
        catch {
        }
    }
}
export function mintOutputStyleReminder(prepared) {
    return prepared.outputStyleFrame === undefined ? undefined : mintSystemReminder(sanitizeUntrustedText(prepared.outputStyleFrame, attachmentEnvelopeTags("output_style")), prepared.reminderMark);
}
async function appendOutputStyleRestate(prepared) {
    const text = mintOutputStyleReminder(prepared);
    if (text === undefined)
        return;
    try {
        await prepared.session.appendMessage({ role: "user", content: [{ type: "text", text }], timestamp: Date.now(), engineMinted: true });
    }
    catch (err) {
        try {
            prepared.postureFrameRef.report?.(new Error(`the output style frame could not be written to the transcript (the next boundary a queued input continues asks again): ${thrownText(err)}`));
        }
        catch {
        }
    }
}
export function appendBoundaryFrames(prepared, turnHadToolCalls) {
    const styleOwed = prepared.outputStyleFrame !== undefined && !turnHadToolCalls && prepared.harness.pendingInjectionCount() > 0;
    const posture = appendOwedPosture(prepared, "on_change");
    return styleOwed ? posture.then(() => appendOutputStyleRestate(prepared)) : posture;
}
export function compactionRestateOptions(prepared) {
    return { ...gitRestateOption(prepared), ...postureRestateOption(prepared) };
}