micro-models-agent 0.47.1 → 0.48.2

package/dist/modules/context/fact-extractor.js

@@ -0,0 +1,162 @@
+import { getMessageText } from "../../llm/provider";
+/**
+ * Regex-based fact extraction from tool/assistant messages. Owns the file /
+ * deleted / decision / error fact lists that survive compaction. Extracted
+ * from ContextManager so the ~115-line regex logic has one home (rule #2).
+ */
+export class FactExtractor {
+    fileFacts = [];
+    deletedFacts = [];
+    decisionFacts = [];
+    errorFacts = [];
+    readFacts = [];
+    static MAX_FACTS = 20;
+    get errorCount() {
+        return this.errorFacts.length;
+    }
+    /** Scan a batch of compacted turns and fold their facts into the lists. */
+    extract(turns) {
+        // Absolute Windows paths ("E:\proj\src\a.ts") need an optional drive prefix;
+        // without it the colon breaks the match and the fact is silently dropped.
+        const DRIVE = "(?:[a-zA-Z]:[\\\\/])?";
+        const createdPatterns = [
+            new RegExp(`(?:Created|Updated|Written|Moved|Replaced in) ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
+            new RegExp(`Файл (?:создан|обновлён|записан|перемещён):? ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
+            new RegExp(`file (?:created|updated|written|moved):? ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
+        ];
+        const deletedPatterns = [
+            new RegExp(`Deleted ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
+            new RegExp(`(?:Удалён|Файл удалён):? ${DRIVE}([\\w./\\\\-]+\\.[a-z]+)`, "gi"),
+        ];
+        // read_file output header — locale-independent prefix `── path (ext, …`
+        // (en: "lines", ru: "строк"). The path is already prefixed with the same
+        // box-drawing marker in both locales, so the pattern needs no localization.
+        const readPatterns = [new RegExp(`── (${DRIVE}[\\w./\\\\-]+\\.[a-z]+) \\(`, "gi")];
+        const newFiles = [];
+        const newDeleted = [];
+        const newDecisions = [];
+        const newErrors = [];
+        const newReads = [];
+        // Track the LAST tool event per path so a delete followed by a re-create
+        // (or vice versa) in the same window resolves to its final state instead of
+        // being both filtered out of [Files:] and reported as [Deleted:].
+        const lastEvent = new Map();
+        for (const msg of turns) {
+            const content = getMessageText(msg.content);
+            // The system prompt is never a fact source — the memory module embeds
+            // errors.md (with historical "Tool X failed Nx" entries from PAST days)
+            // there, and extracting that text as current [Errors:] misleads the model
+            // into thinking IT is failing (observed: ses_msvuao0h — a stale
+            // "edit_file failed 3x" from 2026-08-15 landed in every compaction
+            // summary as if it were the live session's failure).
+            if (msg.role === "system")
+                continue;
+            // Never feed a previous <system-summary> block into new facts — that is
+            // the source of recursive summary nesting (summary inside summary).
+            if (msg.role === "user" &&
+                (content.startsWith("<system-summary>") || content.includes("[Compressed:"))) {
+                continue;
+            }
+            if (msg.role === "tool") {
+                for (const pattern of createdPatterns) {
+                    for (const match of content.matchAll(pattern)) {
+                        newFiles.push(match[1]);
+                        lastEvent.set(match[1], "file");
+                    }
+                }
+                for (const pattern of deletedPatterns) {
+                    for (const match of content.matchAll(pattern)) {
+                        newDeleted.push(match[1]);
+                        lastEvent.set(match[1], "deleted");
+                    }
+                }
+                for (const pattern of readPatterns) {
+                    for (const match of content.matchAll(pattern)) {
+                        newReads.push(match[1]);
+                    }
+                }
+                if (content.includes("Plan:") && content.includes("[")) {
+                    const planLine = content.split("\n").find((line) => line.includes("Plan:"));
+                    if (planLine)
+                        newDecisions.push(planLine.trim());
+                }
+            }
+            if (msg.role === "assistant") {
+                if (content.includes("decided:") || content.includes("decision:")) {
+                    const line = content
+                        .split("\n")
+                        .find((l) => l.includes("decided:") || l.includes("decision:"));
+                    if (line)
+                        newDecisions.push(line.trim().slice(0, 200));
+                }
+            }
+            if (msg.role === "tool" || msg.role === "assistant") {
+                if (content.includes("Error:") ||
+                    content.includes("failed") ||
+                    content.includes("Ошибка:") ||
+                    content.includes("не удалось")) {
+                    const line = content
+                        .split("\n")
+                        .find((l) => l.includes("Error:") ||
+                        l.includes("failed") ||
+                        l.includes("Ошибка:") ||
+                        l.includes("не удалось"));
+                    if (line)
+                        newErrors.push(line.trim().slice(0, 250));
+                }
+            }
+        }
+        // Deduplicate and cap facts to prevent unbounded growth. Files that were
+        // DELETED leave the "known files" list — a deleted file must not keep
+        // being reported as existing (observed: deleted .js files listed in
+        // every [Files: ...] block for the whole session). A path that is deleted
+        // then RE-CREATED (delete_file A → write_file A) is un-deleted: the last
+        // event in the window wins, so it returns to [Files:] and leaves [Deleted:].
+        const dedup = (arr) => [...new Set(arr)];
+        const finalFiles = dedup(newFiles.filter((p) => lastEvent.get(p) === "file"));
+        const finalDeleted = dedup(newDeleted.filter((p) => lastEvent.get(p) === "deleted"));
+        this.fileFacts = dedup([...this.fileFacts, ...finalFiles].filter((p) => !finalDeleted.includes(p))).slice(-FactExtractor.MAX_FACTS);
+        this.deletedFacts = dedup([...this.deletedFacts, ...finalDeleted].filter((p) => !finalFiles.includes(p))).slice(-FactExtractor.MAX_FACTS);
+        this.decisionFacts = dedup([...this.decisionFacts, ...newDecisions]).slice(-FactExtractor.MAX_FACTS);
+        this.errorFacts = dedup([...this.errorFacts, ...newErrors]).slice(-FactExtractor.MAX_FACTS);
+        this.readFacts = dedup([...this.readFacts, ...newReads]).slice(-FactExtractor.MAX_FACTS);
+    }
+    /** `[Files: a; b]` line for a compaction summary, or null. */
+    filesLine() {
+        const deletedSet = new Set(this.deletedFacts);
+        const liveFiles = this.fileFacts.filter((p) => !deletedSet.has(p));
+        if (liveFiles.length === 0)
+            return null;
+        return `[Files: ${liveFiles.slice(-15).join("; ")}]`;
+    }
+    /** `[Deleted: c]` line, or null. */
+    deletedLine() {
+        if (this.deletedFacts.length === 0)
+            return null;
+        return `[Deleted: ${this.deletedFacts.slice(-10).join("; ")}]`;
+    }
+    /** `[Decisions: d]` line, or null. */
+    decisionsLine() {
+        if (this.decisionFacts.length === 0)
+            return null;
+        return `[Decisions: ${this.decisionFacts.slice(-5).join("; ")}]`;
+    }
+    /** `[Errors: e]` line, or null. */
+    errorsLine() {
+        if (this.errorFacts.length === 0)
+            return null;
+        return `[Errors: ${this.errorFacts.slice(-3).join("; ")}]`;
+    }
+    /**
+     * `[Read: p1; p2]` line — files already inspected via read_file. Lets the
+     * model re-orient after compaction without rescanning the whole project: it
+     * knows which files were already read and only re-reads what changed
+     * (observed: post-compaction the model re-read the same files it had already
+     * inspected, because "already read" never survived compaction).
+     */
+    readLine() {
+        if (this.readFacts.length === 0)
+            return null;
+        return `[Read: ${this.readFacts.slice(-12).join("; ")}]`;
+    }
+}

package/dist/modules/context/history.js

@@ -0,0 +1,15 @@
+import { appendFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+export class SessionHistoryWriter {
+    historyPath;
+    constructor(sessionsDir, sessionId) {
+        const sessionDir = join(sessionsDir, sessionId);
+        if (!existsSync(sessionDir)) {
+            mkdirSync(sessionDir, { recursive: true });
+        }
+        this.historyPath = join(sessionDir, 'history.jsonl');
+    }
+    append(msg) {
+        appendFileSync(this.historyPath, JSON.stringify(msg) + '\n', 'utf-8');
+    }
+}

package/dist/modules/context/index.js

@@ -0,0 +1 @@
+export { ContextManager } from "./manager";

package/dist/modules/context/manager.js

@@ -0,0 +1,423 @@
+import { getMessageText } from "../../llm/provider";
+import { FactExtractor } from "./fact-extractor";
+const COMPACTION_INTERVAL = 15;
+const KEEP_LAST_N = 6;
+function summarizeArgs(args) {
+    if (!args)
+        return "";
+    if (typeof args === "string")
+        return args.slice(0, 80);
+    try {
+        const keys = Object.keys(args);
+        return keys.slice(0, 3).join(", ");
+    }
+    catch {
+        return String(args).slice(0, 80);
+    }
+}
+function truncate(s, max) {
+    if (s.length <= max)
+        return s;
+    return s.slice(0, max - 3) + "...";
+}
+function looksLikeErrorPaste(text) {
+    // Error markers.
+    if (/(?:^|\s)ERROR|Error:|error TS\d+|Transform failed|\[plugin:|SyntaxError|Cannot find|Uncaught|exception/i.test(text)) {
+        return true;
+    }
+    // Structural signals of pasted compiler/runtime output: source frames
+    // ("270|  }_s(...)"), path:line:col references, and stack-trace lines.
+    if (/(?:^|\n)\s*\d+\s*\|/.test(text))
+        return true;
+    if (/[\w./\\-]+\.[a-z]{1,6}:\d+:\d+/.test(text))
+        return true;
+    if (/(?:^|\n)\s*at\s+\S+/.test(text))
+        return true;
+    return false;
+}
+export function extractTriedAndFailed(messages) {
+    const failures = new Map();
+    for (const msg of messages) {
+        if (msg.role === "tool" && msg.name && msg.success === false) {
+            const key = `${msg.name}:${summarizeArgs(msg.arguments)}`;
+            const existing = failures.get(key);
+            const errorText = truncate(typeof msg.content === "string" ? msg.content : getMessageText(msg.content), 100);
+            if (existing) {
+                existing.count++;
+            }
+            else {
+                failures.set(key, {
+                    tool: msg.name,
+                    args: summarizeArgs(msg.arguments),
+                    error: errorText,
+                    count: 1,
+                });
+            }
+        }
+    }
+    return Array.from(failures.values()).filter((f) => f.count >= 2);
+}
+export class ContextManager {
+    contextWindow;
+    messages = [];
+    compactedBlock = null;
+    iterationsSinceCompaction = 0;
+    compactionCount = 0;
+    peakTokens = 0;
+    budget;
+    compactionThreshold;
+    facts = new FactExtractor();
+    /** Latest real user instruction (skips <system-summary> blocks). */
+    lastUserTask = "";
+    /** First real user instruction of the session — survives resetUserTurn(). */
+    sessionMission = "";
+    /** Latest user message that looks like a pasted error/log (never a task). */
+    lastUserFeedback = "";
+    tokenCounter;
+    pendingImageParts = [];
+    toolTokens = 0;
+    onCompact = null;
+    /**
+     * Optional short line appended to the compaction summary so the model knows
+     * an active plan exists with progress. Wired from bootstrap to the execution
+     * module — without it, a 9B model re-creates a plan from scratch right after
+     * compaction (observed: ses_msvuao0h — plan_e07pb2 (1/6) was discarded for a
+     * fresh plan_xzq9xe the same iteration the old plan was still visible).
+     */
+    planSummaryProvider = null;
+    constructor(contextWindow, contextBudget, tokenCounter) {
+        this.contextWindow = contextWindow;
+        this.compactionThreshold = contextBudget?.compactionThreshold ?? 0.75;
+        this.budget = this.calculateBudget(contextWindow, contextBudget);
+        this.tokenCounter = tokenCounter ?? null;
+    }
+    /**
+     * Provide a short "current plan" line for the compaction summary, or null
+     * when no plan is active. Injected once at bootstrap (not per-turn state).
+     */
+    setPlanSummaryProvider(fn) {
+        this.planSummaryProvider = fn;
+    }
+    calculateBudget(window, contextBudget) {
+        if (contextBudget) {
+            const systemPrompt = Math.floor(window * contextBudget.systemPrompt);
+            const responseReserve = Math.floor(window * contextBudget.responseReserve);
+            const history = Math.max(0, window - systemPrompt - responseReserve);
+            return { systemPrompt, responseReserve, history };
+        }
+        // Fallback for backwards compatibility (tests, subagents without explicit budget)
+        return {
+            systemPrompt: Math.floor(window * 0.25),
+            responseReserve: Math.floor(window * 0.12),
+            history: Math.floor(window * 0.63),
+        };
+    }
+    getBudget() {
+        return { ...this.budget };
+    }
+    getCompactionCount() {
+        return this.compactionCount;
+    }
+    getIterationsSinceCompaction() {
+        return this.iterationsSinceCompaction;
+    }
+    noteIteration() {
+        this.iterationsSinceCompaction++;
+    }
+    /**
+     * Start a fresh user turn. The 15-iteration compaction interval must not
+     * leak across user messages — otherwise a turn that ends at iteration 14
+     * forces a compaction on the very first iteration of the next user message
+     * (observed: compaction fired on iteration 8 of a new turn, deleting the
+     * user's freshly-sent task alongside 40+ old turns). Facts are kept.
+     */
+    resetUserTurn() {
+        this.iterationsSinceCompaction = 0;
+        // A new user message begins a new turn — drop the previous turn's task
+        // so the fresh instruction becomes the one preserved at compaction. The
+        // session mission survives: an error/log paste in the new turn must not
+        // erase the original goal.
+        this.lastUserTask = "";
+        this.lastUserFeedback = "";
+    }
+    getQuality() {
+        const usedTokens = this.getEstimatedTokens();
+        const tokenLoad = Math.max(0, 1 - usedTokens / this.budget.history);
+        // Recoverable penalty: each compaction loses some information, but the
+        // penalty is CAPPED so cumulative compactions can never permanently pin
+        // quality below the forced-compaction trigger (40%). Before this cap, a
+        // session with ~7+ compactions clamped the term to 0 forever; combined
+        // with heavy token load + error density, quality stuck below 40 and a
+        // compaction fired on EVERY iteration (observed: 56 compactions in 28 min).
+        const COMPACTION_PENALTY_FLOOR = 0.5;
+        const compactionLoss = Math.max(COMPACTION_PENALTY_FLOOR, 1 - this.compactionCount * 0.15);
+        const msgCount = this.messages.length || 1;
+        const errorDensity = Math.max(0, 1 - Math.min(1, this.facts.errorCount / msgCount));
+        const freshness = Math.max(0, 1 - this.iterationsSinceCompaction / COMPACTION_INTERVAL);
+        const score = tokenLoad * 0.4 + compactionLoss * 0.25 + errorDensity * 0.2 + freshness * 0.15;
+        return Math.round(Math.min(100, Math.max(0, score * 100)));
+    }
+    addMessage(msg) {
+        // Track the task the agent is working on so it survives compaction. The
+        // user's real instruction is the FIRST non-system-summary user message of
+        // the turn; everything after it (tool results, retry nudges) are injected
+        // `user` envelopes that must not overwrite it (observed: after compaction
+        // the model had forgotten "удали /bicycles, почини стили" and re-read
+        // files aimlessly for 40+ iterations).
+        if (msg.role === "user") {
+            const text = typeof msg.content === "string" ? msg.content : getMessageText(msg.content);
+            if (text.trim() && !text.startsWith("<system-summary>") && !text.includes("[Compressed:")) {
+                if (looksLikeErrorPaste(text) && (this.lastUserTask || this.sessionMission)) {
+                    this.lastUserFeedback = text.trim().slice(0, 400);
+                }
+                else if (!this.lastUserTask && !this.lastUserFeedback) {
+                    // No new task inside a turn that already captured an error/log paste:
+                    // the paste's follow-up messages are tool-result continuations, not a
+                    // fresh instruction, so the session mission must win at compaction.
+                    this.lastUserTask = text.trim();
+                    if (!this.sessionMission)
+                        this.sessionMission = text.trim();
+                }
+            }
+        }
+        // Auto-attach pending images to the next user message
+        if (msg.role === "user" && this.pendingImageParts.length > 0) {
+            const textPart = {
+                type: "text",
+                text: typeof msg.content === "string" ? msg.content : getMessageText(msg.content),
+            };
+            msg = {
+                ...msg,
+                content: [textPart, ...this.pendingImageParts],
+            };
+            this.pendingImageParts = [];
+        }
+        this.messages.push(msg);
+        const tokens = this.getEstimatedTokens();
+        if (tokens > this.peakTokens)
+            this.peakTokens = tokens;
+    }
+    /**
+     * Queue an image part to be attached to the next user message.
+     */
+    addPendingImage(part) {
+        this.pendingImageParts.push(part);
+    }
+    /**
+     * Check if there are pending images waiting to be attached.
+     */
+    hasPendingImages() {
+        return this.pendingImageParts.length > 0;
+    }
+    /**
+     * Get pending image parts without clearing them.
+     */
+    getPendingImages() {
+        return [...this.pendingImageParts];
+    }
+    /**
+     * Clear pending images (e.g., if user sends a text-only message).
+     */
+    clearPendingImages() {
+        this.pendingImageParts = [];
+    }
+    getMessageCount() {
+        return this.messages.length;
+    }
+    estimateMessageTokens(m) {
+        const text = getMessageText(m.content);
+        if (this.tokenCounter) {
+            let t = this.tokenCounter.count(text);
+            // Image tokens: base64 ~130 tokens per 512x512 tile; rough estimate
+            if (Array.isArray(m.content)) {
+                for (const part of m.content) {
+                    if (part.type === "image_url" && part.image_url?.url) {
+                        const b64Len = part.image_url.url.includes(",")
+                            ? (part.image_url.url.split(",")[1]?.length ?? 0)
+                            : part.image_url.url.length;
+                        // ~130 tokens per 512 bytes of base64
+                        t += Math.ceil(b64Len / 512) * 130;
+                    }
+                }
+            }
+            if (m.tool_calls) {
+                for (const tc of m.tool_calls) {
+                    t += this.tokenCounter.count(tc.id);
+                    t += this.tokenCounter.count(tc.function.name);
+                    t += this.tokenCounter.count(tc.function.arguments);
+                    t += 4;
+                }
+            }
+            return t;
+        }
+        let t = Math.ceil(text.length / 2);
+        if (Array.isArray(m.content)) {
+            for (const part of m.content) {
+                if (part.type === "image_url" && part.image_url?.url) {
+                    const b64Len = part.image_url.url.includes(",")
+                        ? (part.image_url.url.split(",")[1]?.length ?? 0)
+                        : part.image_url.url.length;
+                    t += Math.ceil(b64Len / 512) * 130;
+                }
+            }
+        }
+        if (m.tool_calls) {
+            for (const tc of m.tool_calls) {
+                t += Math.ceil(tc.id.length / 2);
+                t += Math.ceil(tc.function.name.length / 2);
+                t += Math.ceil(tc.function.arguments.length / 2);
+                t += 4;
+            }
+        }
+        return t;
+    }
+    needsCompaction() {
+        if (this.iterationsSinceCompaction >= COMPACTION_INTERVAL)
+            return true;
+        const totalTokens = this.messages.reduce((sum, m) => sum + this.estimateMessageTokens(m), 0);
+        return totalTokens > this.budget.history * this.compactionThreshold;
+    }
+    compact() {
+        // Capture the pre-compaction state BEFORE any counters reset or rise —
+        // qualityBefore must reflect the context the model actually saw.
+        const tokensBefore = this.getEstimatedTokens();
+        const qualityBefore = this.getQuality();
+        const messagesBefore = this.messages.length;
+        // Reset the counter even when nothing to compact — otherwise
+        // needsCompaction() returns true forever after 15 iterations with few messages.
+        this.iterationsSinceCompaction = 0;
+        if (this.messages.length <= KEEP_LAST_N * 2)
+            return null;
+        this.compactionCount++;
+        const cutoff = this.messages.length - KEEP_LAST_N * 2;
+        const oldTurns = this.messages.slice(0, cutoff);
+        const recentTurns = this.messages.slice(cutoff);
+        this.facts.extract(oldTurns);
+        const parts = [];
+        parts.push(`[Compressed: ${oldTurns.length} old turns removed]`);
+        // Carry the user's actual instruction forward — the model must never lose
+        // the task it is working on just because 40 turns got compacted away. The
+        // per-turn task falls back to the session mission (first real instruction)
+        // so a pasted error/log in the current turn cannot erase the goal.
+        const task = (this.lastUserTask || this.sessionMission).slice(0, 400);
+        if (task)
+            parts.push(`[Task: ${task}]`);
+        if (this.lastUserFeedback && !task.startsWith(this.lastUserFeedback)) {
+            parts.push(`[User feedback: ${this.lastUserFeedback}]`);
+        }
+        // Orient the model after compaction: an active plan must not be re-created
+        // from scratch (see planSummaryProvider doc).
+        const planLine = this.planSummaryProvider?.();
+        if (planLine)
+            parts.push(`[Plan: ${planLine}]`);
+        const filesLine = this.facts.filesLine();
+        if (filesLine)
+            parts.push(filesLine);
+        const deletedLine = this.facts.deletedLine();
+        if (deletedLine)
+            parts.push(deletedLine);
+        const readLine = this.facts.readLine();
+        if (readLine)
+            parts.push(readLine);
+        const decisionsLine = this.facts.decisionsLine();
+        if (decisionsLine)
+            parts.push(decisionsLine);
+        const errorsLine = this.facts.errorsLine();
+        if (errorsLine)
+            parts.push(errorsLine);
+        const triedAndFailed = extractTriedAndFailed(oldTurns);
+        if (triedAndFailed.length > 0) {
+            const lines = triedAndFailed.map((t) => `- ${t.tool}(${t.args}): ${t.error} (failed ${t.count}x)`);
+            parts.push(`[Already tried & failed — do NOT repeat:]\n${lines.join("\n")}`);
+        }
+        this.compactedBlock = parts.join(" ");
+        const summary = {
+            role: "user",
+            content: `<system-summary>${this.compactedBlock}</system-summary>`,
+        };
+        const firstSystem = this.messages.find((m) => m.role === "system");
+        // Filter out stale system-summary messages from recent turns to prevent nesting
+        const freshRecent = recentTurns.filter((m) => {
+            if (m.role !== "user")
+                return true;
+            const text = getMessageText(m.content);
+            return !text.startsWith("<system-summary>");
+        });
+        this.messages = [...(firstSystem ? [firstSystem] : []), summary, ...freshRecent];
+        this.iterationsSinceCompaction = 0;
+        if (this.onCompact) {
+            this.onCompact(summary);
+        }
+        return {
+            removedTurns: oldTurns.length,
+            keptTurns: freshRecent.length,
+            tokensBefore,
+            tokensAfter: this.getEstimatedTokens(),
+            qualityBefore,
+            qualityAfter: this.getQuality(),
+            messagesBefore,
+            messagesAfter: this.messages.length,
+            summary: this.compactedBlock ?? "",
+        };
+    }
+    /**
+     * Snapshot of the current context state — used to log the initial context
+     * structure at session start and per-iteration context stats.
+     */
+    getSnapshot() {
+        return {
+            window: this.contextWindow,
+            budget: { ...this.budget },
+            tokens: this.getEstimatedTokens(),
+            toolTokens: this.toolTokens,
+            messageCount: this.messages.length,
+            quality: this.getQuality(),
+            compactionCount: this.compactionCount,
+            iterationsSinceCompaction: this.iterationsSinceCompaction,
+        };
+    }
+    /**
+     * Replace the system prompt in place (keeps it first) or prepend a new one.
+     * Used to refresh dynamic prompt blocks (e.g. the plan checklist) mid-run.
+     */
+    updateSystemPrompt(content) {
+        const idx = this.messages.findIndex((m) => m.role === "system");
+        if (idx >= 0) {
+            this.messages[idx] = { ...this.messages[idx], content };
+        }
+        else {
+            this.messages.unshift({ role: "system", content });
+        }
+    }
+    getActiveHistory() {
+        return [...this.messages];
+    }
+    /**
+     * Reset everything that belongs to the current conversation turn.
+     * Fact lists (FactExtractor) intentionally survive clear() — they are
+     * session-scoped compaction state, not per-turn.
+     */
+    clear() {
+        this.messages = [];
+        this.compactedBlock = null;
+        this.iterationsSinceCompaction = 0;
+        this.compactionCount = 0;
+        this.peakTokens = 0;
+        this.lastUserTask = "";
+        this.lastUserFeedback = "";
+        this.sessionMission = "";
+    }
+    getEstimatedTokens() {
+        return (this.messages.reduce((sum, m) => sum + this.estimateMessageTokens(m), 0) + this.toolTokens);
+    }
+    setToolTokens(tokens) {
+        this.toolTokens = tokens;
+    }
+    resize(contextWindow, contextBudget, tokenCounter) {
+        this.contextWindow = contextWindow;
+        this.budget = this.calculateBudget(contextWindow, contextBudget);
+        if (tokenCounter !== undefined) {
+            this.tokenCounter = tokenCounter ?? null;
+        }
+    }
+}