@superblocksteam/vite-plugin-file-sync 2.0.42-next.5 → 2.0.42-next.50

package/dist/ai-service/llm/context/context.js

@@ -0,0 +1,742 @@
+/**
+ * Main Context class for managing LLM conversation context.
+ *
+ * Responsibilities:
+ * - Maintain conversation turns across three compression levels
+ * - Automatically compact context when token limits are approached
+ * - Track and refine character-to-token estimation
+ * - Persist context state for resumption
+ *
+ * The three-level compaction strategy:
+ * - L1 (50%): Recent turns with full detail
+ * - L2 (35%): Older turns with moderate compression
+ * - L3 (15%): Oldest turns with maximum compression
+ */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import llmobs from "../../llmobs/index.js";
+import { safeJsonStringify } from "../../util/safe-stringify.js";
+import { CACHE_BREAKPOINT_PROVIDER_OPTIONS, } from "./caching/index.js";
+import { UserPromptTooLargeError, ContextLimitExceededError, } from "./errors.js";
+import { L1Turn, L2Turn, L3Turn } from "./levels/index.js";
+import { createPrefixedLogger } from "./logger.js";
+import { withContextDefaults, withLoggingDefaults, } from "./options.js";
+import { estimateTokenCount, countChars, normalizeToolResultOutput, } from "./utils/index.js";
+import { prependReasoningBlockIfNeeded } from "./utils/message-utils.js";
+import { renderContext, } from "./utils/visualization.js";
+/**
+ * Context manages conversation history with automatic compaction.
+ * Note: you generally want to use the ContextManager to obtain a Context instance.
+ */
+let Context = (() => {
+    let _instanceExtraInitializers = [];
+    let _compact_decorators;
+    return class Context {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _compact_decorators = [llmobs.decorate({ name: "Context.compact", kind: "task" })];
+            __esDecorate(this, null, _compact_decorators, { kind: "method", name: "compact", static: false, private: false, access: { has: obj => "compact" in obj, get: obj => obj.compact }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        id = __runInitializers(this, _instanceExtraInitializers);
+        options;
+        logging;
+        systemPrompt;
+        l3Turns = [];
+        l2Turns = [];
+        l1Turns = [];
+        onPersist;
+        // num responses received in active turn
+        // need to track this to dedup responses from streamText.onStepFinish
+        activeTurnNumResponses = 0;
+        // links split turns
+        continuations = new WeakMap();
+        // start time of current turn
+        // so we can show turn durations in viz
+        turnStartMs = 0;
+        // cached logger with prefix and verbose gating
+        _logger = null;
+        // cache strategy for breakpoint placement
+        cacheStrategy;
+        constructor(params) {
+            const { id, options, logging, onPersist, cacheStrategy } = params;
+            this.id = id;
+            this.options = withContextDefaults(options);
+            this.logging = withLoggingDefaults(logging);
+            this.onPersist = onPersist;
+            this.cacheStrategy = cacheStrategy;
+        }
+        get charsPerToken() {
+            return this.options.charsPerToken;
+        }
+        logPrefix() {
+            const name = this.id?.name;
+            return name ? `[context:${name}]` : "[context]";
+        }
+        get logger() {
+            if (!this._logger) {
+                this._logger = createPrefixedLogger(this.logPrefix(), this.logging.verbose);
+            }
+            return this._logger;
+        }
+        async persist() {
+            if (this.onPersist) {
+                await this.onPersist(this.toRecord());
+            }
+        }
+        /**
+         * Seed empty context with a summary message.
+         */
+        seedIfEmpty(summary) {
+            if (this.turnMessages.length > 0) {
+                return;
+            }
+            this.l3Turns.push(new L3Turn(this.withTokenCount(summary)));
+        }
+        /**
+         * Returns all messages in order (system + L3 + L2 + L1).
+         *
+         * Messages are returned without token counts (clean ModelMessage format).
+         */
+        getMessages() {
+            const breakPoints = this.cacheStrategy.findBreakpoints({
+                messages: this.allMessages,
+                tokens: {
+                    total: this.tokenCount,
+                    system: this.systemPromptTokenCount,
+                },
+                options: this.options.caching,
+            });
+            this.logger.debug(`Cache: ${breakPoints.length} breakpoints`);
+            const messages = this.allMessages.map((msg, index, msgs) => {
+                if (breakPoints.includes(index)) {
+                    msg.hasBreakPoint = true;
+                }
+                else if (msg.hasBreakPoint) {
+                    delete msg.hasBreakPoint;
+                }
+                return this.toModelMessage(msg, index, msgs);
+            });
+            for (const idx of breakPoints) {
+                messages[idx].providerOptions = CACHE_BREAKPOINT_PROVIDER_OPTIONS;
+            }
+            return messages;
+        }
+        /**
+         * Total token count across all context (system + all turns).
+         */
+        get tokenCount() {
+            let total = 0;
+            total += this.systemPrompt?.tokenCount ?? 0;
+            for (const turn of this.l3Turns) {
+                total += turn.tokenCount;
+            }
+            for (const turn of this.l2Turns) {
+                total += turn.tokenCount;
+            }
+            for (const turn of this.l1Turns) {
+                total += turn.tokenCount;
+            }
+            return total;
+        }
+        /**
+         * Token count for system prompt only.
+         */
+        get systemPromptTokenCount() {
+            if (!this.systemPrompt)
+                return 0;
+            return this.systemPrompt.tokenCount;
+        }
+        /**
+         * Currently active turn (last L1 turn if not ended).
+         */
+        get activeTurn() {
+            return this.l1Turns.at(-1);
+        }
+        /**
+         * Currently active step within active turn.
+         */
+        get activeStep() {
+            return this.activeTurn?.steps.at(-1);
+        }
+        /**
+         * All turn messages (L3 + L2 + L1), excluding continuation markers.
+         */
+        get turnMessages() {
+            const messages = [];
+            messages.push(...this.l3Turns.flatMap((turn) => turn.messages));
+            messages.push(...this.l2Turns.flatMap((turn) => turn.messages));
+            messages.push(...this.l1Turns.flatMap((turn) => turn.messages));
+            // filter out continuation marker messages
+            return messages.filter((msg) => msg.role !== "user" ||
+                msg.originalUserMessage == undefined);
+        }
+        /**
+         * All messages including system prompt.
+         */
+        get allMessages() {
+            return [
+                ...(this.systemPrompt ? [this.systemPrompt] : []),
+                ...this.turnMessages,
+            ];
+        }
+        getLevelBudgets() {
+            return this.calculateLevelBudgets(this.options.compaction.target);
+        }
+        /**
+         * Sets the system prompt.
+         */
+        setSystemPrompt(message) {
+            this.systemPrompt = {
+                ...message,
+                tokenCount: this.estimateTokenCount(message),
+            };
+            this.logger.debug(`Set system prompt with ${this.systemPromptTokenCount} tokens`);
+            this.compact(this.options.maxTokens);
+        }
+        /**
+         * Retrieves the current system prompt (if any).
+         */
+        getSystemPrompt() {
+            if (!this.systemPrompt)
+                return undefined;
+            const { tokenCount, hasBreakPoint, ...msg } = this.systemPrompt;
+            return msg;
+        }
+        /**
+         * Starts a new conversation turn with a user message.
+         *
+         * @throws {UserPromptTooLargeError} If user + system exceeds maxTokens and no options.allowOverflow is false
+         */
+        startTurn(user) {
+            this.turnStartMs = Date.now();
+            const tokenizedUser = this.withTokenCount(user);
+            // Validate that user messages + system prompt doesn't exceed maxTokens
+            const userAndSystemTokens = tokenizedUser.tokenCount + this.systemPromptTokenCount;
+            if (userAndSystemTokens > this.options.maxTokens) {
+                this.logger.warn(`User prompt too large: ${tokenizedUser.tokenCount} + ${this.systemPromptTokenCount} (system prompt) > ${this.options.maxTokens}.`);
+                if (!this.options.allowOverflow) {
+                    const info = {
+                        userTokens: tokenizedUser.tokenCount,
+                        systemTokens: this.systemPromptTokenCount,
+                        maxTokens: this.options.maxTokens,
+                        combined: userAndSystemTokens,
+                    };
+                    throw new UserPromptTooLargeError(info);
+                }
+            }
+            const newTurn = new L1Turn(tokenizedUser);
+            this.l1Turns.push(newTurn);
+            this.compact(this.options.maxTokens);
+            void this.persist();
+        }
+        /**
+         * Starts a new step within the active turn.
+         */
+        startStep() {
+            if (!this.activeTurn) {
+                throw new Error("No active turn to start a step in.");
+            }
+            this.logger.info(`Starting new step in active turn`);
+            if (this.tokenCount > this.options.maxTokens) {
+                this.onContextLimitExceeded();
+            }
+            this.activeTurn.steps.push([]);
+        }
+        /**
+         * Ends the current step, adding response messages.
+         *
+         * @param responses - Assistant and/or tool messages, accumulated over the entire active turn (this is how streamText.onStepFinish provides them)
+         * @param usage - Optional token usage info for refining estimates
+         */
+        endStep(responses, usage) {
+            if (!this.activeStep) {
+                this.logger.warn(`endStep called without an active step - ignoring responses`);
+                return;
+            }
+            const newResponses = responses.slice(this.activeTurnNumResponses);
+            this.activeTurnNumResponses = responses.length;
+            this.logger.debug(`Ending step with ${newResponses.length} responses`);
+            if (usage) {
+                this.updateCharsPerTokenEstimate(usage);
+            }
+            this.activeStep.push(...newResponses.map((msg) => this.withTokenCount(msg)));
+            // Split old steps from active turn if needed (keep recent steps active)
+            this.splitActiveTurn();
+            this.compact(this.options.maxTokens);
+            this.printState({ message: "endStep", usage });
+            void this.persist();
+        }
+        /**
+         * Ends the active turn.
+         */
+        endTurn(usage) {
+            if (!this.activeTurn) {
+                this.logger.warn(`endTurn called without an active turn`);
+                return;
+            }
+            const durationMs = Date.now() - this.turnStartMs;
+            this.activeTurnNumResponses = 0;
+            this.logger.debug(`Ending active turn`);
+            this.compact(this.options.maxTokens, false);
+            this.printState({ message: "endTurn", usage, durationMs });
+        }
+        /**
+         * Updates the character-per-token estimate based on actual LLM usage.
+         */
+        updateCharsPerTokenEstimate(usage) {
+            const inputChars = this.allMessages.reduce((sum, msg) => sum + countChars(msg), 0);
+            const actualInputTokens = (usage.inputTokens ?? 0) + (usage.cachedInputTokens ?? 0);
+            if (actualInputTokens >= this.options.tokenEstimation.minTokensForUpdate &&
+                actualInputTokens !== this.tokenCount) {
+                const newEstimate = inputChars / actualInputTokens;
+                if (newEstimate >= this.options.tokenEstimation.minCharsPerToken &&
+                    newEstimate <= this.options.tokenEstimation.maxCharsPerToken) {
+                    this.logger.debug(`Step input: ${inputChars} characters, estimated tokens: ${this.tokenCount}, actual tokens: ${usage.inputTokens ?? 0} (${JSON.stringify(usage)})`);
+                    this.options.charsPerToken = newEstimate;
+                    this.logger.info(`Updated charactersPerToken estimate: ${this.options.charsPerToken.toFixed(2)}`);
+                    this.recalculateTokenCounts();
+                }
+                else {
+                    this.logger.warn(`Ignoring unreasonable charactersPerToken estimate: ${newEstimate.toFixed(2)}`);
+                }
+            }
+        }
+        /**
+         * Recalculates all token counts with current estimate.
+         */
+        recalculateTokenCounts() {
+            for (const msg of this.allMessages) {
+                msg.tokenCount = estimateTokenCount(msg, this.options.charsPerToken);
+            }
+            this.logger.debug(`Recalculated context token count: ${this.tokenCount} tokens`);
+        }
+        /**
+         * Main compaction algorithm.
+         *
+         * Triggers when context exceeds compactionTrigger threshold.
+         * Demotes/drops turns to reach compactionTarget.
+         * TODO(matt): add final AI summary level
+         *
+         * @param maxTokens - Hard token limit
+         * @param lastTurnIsActive - Whether last L1 turn is active (protected from demotion)
+         */
+        compact(maxTokens, lastTurnIsActive = true) {
+            const effectiveTrigger = Math.min(this.options.compaction.trigger, maxTokens);
+            const effectiveTarget = Math.min(this.options.compaction.target, maxTokens);
+            // Skip compaction only if under trigger
+            if (this.tokenCount < effectiveTrigger) {
+                this.logger.debug(`Skipping compaction: ${this.tokenCount} < ${effectiveTrigger} tokens`);
+                return;
+            }
+            const initialTokenCount = this.tokenCount;
+            const l1Count = this.l1Turns.length;
+            const l2Count = this.l2Turns.length;
+            const l3Count = this.l3Turns.length;
+            this.logger.info(`Compaction triggered: ${this.tokenCount} tokens (trigger: ${effectiveTrigger}, target: ${effectiveTarget}) | L1=${l1Count} L2=${l2Count} L3=${l3Count}`);
+            const { l1, l2, l3 } = this.options.compaction.budgets;
+            const budgets = this.calculateLevelBudgets(effectiveTarget);
+            this.logger.debug(`Level targets - L1: ${budgets.l1} (${(l1 * 100).toPrecision(2)}%), L2: ${budgets.l2} (${(l2 * 100).toPrecision(2)}%), L3: ${budgets.l3} (${(l3 * 100).toPrecision(2)}%)`);
+            // Compact each level to its target
+            this.compactL1ToTarget(budgets.l1, lastTurnIsActive);
+            this.compactL2ToTarget(budgets.l2);
+            this.compactL3ToTarget(budgets.l3);
+            // Aggressive compaction if still over max tokens
+            this.performAggressiveCompaction(maxTokens);
+            const finalTokenCount = this.tokenCount;
+            const finalL1 = this.l1Turns.length;
+            const finalL2 = this.l2Turns.length;
+            const finalL3 = this.l3Turns.length;
+            const reducedBy = initialTokenCount - finalTokenCount;
+            const reducedByPercent = (reducedBy / initialTokenCount) * 100;
+            this.logger.info(`Compaction complete: ${initialTokenCount}→${finalTokenCount} tokens (-${reducedBy}, -${reducedByPercent.toFixed(1)}%) | L1=${l1Count}→${finalL1}, L2=${l2Count}→${finalL2}, L3=${l3Count}→${finalL3}`);
+            // Log if compaction occurred
+            const compactionOccurred = initialTokenCount !== finalTokenCount ||
+                l1Count + l2Count + l3Count !== finalL1 + finalL2 + finalL3;
+            if (compactionOccurred) {
+                this.logger.debug("Compaction occurred");
+            }
+            // Check if we're still over maxTokens after all compaction
+            if (this.tokenCount > maxTokens) {
+                this.logger.warn(`Still exceeds max after compaction: ${this.tokenCount} > ${maxTokens} - consider increasing maxTokens`);
+            }
+        }
+        onContextLimitExceeded() {
+            this.logger.warn(`Context limit exceeded: ${this.tokenCount} > ${this.options.maxTokens}`);
+            if (this.options.allowOverflow) {
+                return;
+            }
+            const activeStepTokens = this.activeStep?.reduce((sum, msg) => sum + msg.tokenCount, 0) ?? 0;
+            const userTokens = this.activeTurn?.user.tokenCount ?? 0;
+            const historyTokens = this.l3Turns.reduce((sum, turn) => sum + turn.tokenCount, 0) +
+                this.l2Turns.reduce((sum, turn) => sum + turn.tokenCount, 0) +
+                this.l1Turns.slice(0, -1).reduce((sum, turn) => sum + turn.tokenCount, 0);
+            const info = {
+                currentTokens: this.tokenCount,
+                maxTokens: this.options.maxTokens,
+                breakdown: {
+                    system: this.systemPromptTokenCount,
+                    user: userTokens,
+                    activeStep: activeStepTokens,
+                    history: historyTokens,
+                },
+            };
+            throw new ContextLimitExceededError(info);
+        }
+        /**
+         * Calculates budget allocations for each compression level.
+         */
+        calculateLevelBudgets(target) {
+            const availableForLevels = Math.max(0, target - this.systemPromptTokenCount);
+            const { l1, l2, l3 } = this.options.compaction.budgets;
+            return {
+                l1: Math.floor(availableForLevels * l1),
+                l2: Math.floor(availableForLevels * l2),
+                l3: Math.floor(availableForLevels * l3),
+            };
+        }
+        /**
+         * Compacts L1 turns to fit within target budget.
+         */
+        compactL1ToTarget(target, lastTurnIsActive = true) {
+            const getL1Tokens = () => this.l1Turns.reduce((sum, turn) => sum + turn.tokenCount, 0);
+            const l1Before = getL1Tokens();
+            let demoted = 0;
+            // Splits old steps out from active turn so they can be demoted if needed
+            this.splitActiveTurn();
+            while (getL1Tokens() > target &&
+                this.l1Turns.length > (lastTurnIsActive ? 1 : 0)) {
+                const turn = this.l1Turns.shift();
+                const compacted = turn.compact(this.options.charsPerToken);
+                // If this is a continuation user message, try to merge with previous L2 turn
+                if (compacted.user.originalUserMessage && this.l2Turns.length > 0) {
+                    const lastL2 = this.l2Turns.at(-1);
+                    lastL2.responses.push(...compacted.responses);
+                    lastL2.user.originalUserMessage = undefined; // Clear originalUserMessage since it's now merged
+                }
+                else {
+                    compacted.user = compacted.user.originalUserMessage ?? compacted.user;
+                    this.l2Turns.push(compacted);
+                }
+                demoted++;
+            }
+            if (demoted > 0) {
+                this.logger.debug(`L1 compaction: ${demoted} turns demoted, ${l1Before}→${getL1Tokens()} tokens`);
+            }
+        }
+        /**
+         * Compacts L2 turns to fit within target budget.
+         */
+        compactL2ToTarget(target) {
+            const getL2Tokens = () => this.l2Turns.reduce((sum, turn) => sum + turn.tokenCount, 0);
+            const l2Before = getL2Tokens();
+            let demoted = 0;
+            while (getL2Tokens() > target && this.l2Turns.length > 0) {
+                const turn = this.l2Turns.shift();
+                const compacted = turn.compact();
+                this.l3Turns.push(compacted);
+                demoted++;
+            }
+            if (demoted > 0) {
+                this.logger.debug(`L2 compaction: ${demoted} turns demoted, ${l2Before}→${getL2Tokens()} tokens`);
+            }
+        }
+        /**
+         * Compacts L3 turns to fit within target budget by dropping oldest.
+         */
+        compactL3ToTarget(target) {
+            const getL3Tokens = () => this.l3Turns.reduce((sum, turn) => sum + turn.tokenCount, 0);
+            const l3Before = getL3Tokens();
+            let dropped = 0;
+            while (getL3Tokens() > target && this.l3Turns.length > 0) {
+                const turn = this.l3Turns.shift();
+                this.patchContinuationBeforeDrop(turn.user);
+                dropped++;
+            }
+            if (dropped > 0) {
+                this.logger.debug(`L3 compaction: ${dropped} turns dropped, ${l3Before}→${getL3Tokens()} tokens`);
+            }
+        }
+        /*
+         * Restore original user message to next continuation before dropping turn.
+         */
+        patchContinuationBeforeDrop(user) {
+            if (!this.continuations.has(user)) {
+                return;
+            }
+            const next = this.continuations.get(user);
+            next.content = next.originalUserMessage.content;
+            next.tokenCount = this.estimateTokenCount(next);
+            this.continuations.delete(user);
+        }
+        /**
+         * Performs aggressive compaction when still over target after level-based compaction.
+         */
+        performAggressiveCompaction(target) {
+            if (this.tokenCount <= target)
+                return;
+            this.logger.debug(`Performing aggressive compaction: ${this.tokenCount} > ${target} tokens`);
+            let aggressiveDemotions = 0;
+            const l1Count = this.l1Turns.length;
+            const l2Count = this.l2Turns.length;
+            const l3Count = this.l3Turns.length;
+            // split all but two most recent steps out from active turn
+            this.splitActiveTurn(2);
+            while (this.tokenCount > target) {
+                if (this.l1Turns.length > 1) {
+                    const turn = this.l1Turns.shift();
+                    this.l2Turns.push(turn.compact(this.options.charsPerToken));
+                    aggressiveDemotions++;
+                    continue;
+                }
+                if (this.l2Turns.length) {
+                    const turn = this.l2Turns.shift();
+                    this.l3Turns.push(turn.compact());
+                    aggressiveDemotions++;
+                    continue;
+                }
+                if (this.l3Turns.length) {
+                    const turn = this.l3Turns.shift();
+                    this.patchContinuationBeforeDrop(turn.user);
+                    aggressiveDemotions++;
+                    continue;
+                }
+                break;
+            }
+            const finalL1 = this.l1Turns.length;
+            const finalL2 = this.l2Turns.length;
+            const finalL3 = this.l3Turns.length;
+            if (aggressiveDemotions > 0) {
+                this.logger.debug(`Aggressive compaction: ${aggressiveDemotions} additional turns processed | | L1=${l1Count}→${finalL1}, L2=${l2Count}→${finalL2}, L3=${l3Count}→${finalL3}`);
+            }
+        }
+        /**
+         * Splits old steps from active turn into a completed L1 turn when appropriate.
+         *
+         * Strategy:
+         * - Split when turn has more than `prioritizedSteps` steps
+         * - Merge with previous split turn if it exists (via continuations map)
+         *
+         * This keeps recent steps in the active turn while moving older steps
+         * to a completed turn that can be cached and potentially compacted.
+         */
+        splitActiveTurn(stepsToKeep) {
+            if (!this.activeTurn)
+                return;
+            const minSteps = stepsToKeep ?? this.options.compaction.prioritizedSteps;
+            // Need more than minSteps to split
+            if (this.activeTurn.steps.length <= minSteps) {
+                return;
+            }
+            const stepsToSplit = this.activeTurn.steps.length - minSteps;
+            this.performSplit(stepsToSplit);
+        }
+        /**
+         * Performs the actual split operation.
+         *
+         * If a previous split turn exists (linked via continuations), merges steps into it.
+         * Otherwise creates a new completed turn.
+         */
+        performSplit(stepsToCacheable) {
+            if (!this.activeTurn)
+                return;
+            const initialStepCount = this.activeTurn.steps.length;
+            const initialTokens = this.activeTurn.tokenCount;
+            // Extract old steps
+            const oldSteps = this.activeTurn.steps.splice(0, stepsToCacheable);
+            // Check if previous turn is a continuation from same user message
+            const prevTurn = this.l1Turns[this.l1Turns.length - 2]; // -2 because active is at -1
+            if (prevTurn &&
+                this.continuations.get(prevTurn.user) === this.activeTurn.user) {
+                // Merge: append steps to existing split turn
+                prevTurn.steps.push(...oldSteps);
+                this.logger.info(`Merged ${stepsToCacheable} steps into existing split turn (${initialStepCount}→${this.activeTurn.steps.length} steps in active turn, ${initialTokens}→${this.activeTurn.tokenCount} tokens)`);
+            }
+            else {
+                // Create new split turn
+                const completedTurn = new L1Turn(this.activeTurn.user);
+                completedTurn.steps = oldSteps;
+                // Insert the completed turn before the active turn
+                this.l1Turns.splice(this.l1Turns.length - 1, 0, completedTurn);
+                // Replace active turn's user message with continuation marker (if not already)
+                if (!this.activeTurn.user.originalUserMessage) {
+                    const continuationUser = {
+                        role: "user",
+                        content: "[Continuing previous interaction...]",
+                        originalUserMessage: this.activeTurn.user,
+                        tokenCount: 0,
+                    };
+                    continuationUser.tokenCount = this.estimateTokenCount(continuationUser);
+                    this.activeTurn.user = continuationUser;
+                }
+                this.continuations.set(completedTurn.user, this.activeTurn.user);
+                this.logger.info(`Split ${stepsToCacheable} old steps into new L1 turn (${initialStepCount}→${this.activeTurn.steps.length} steps in active turn, ${initialTokens}→${this.activeTurn.tokenCount} tokens)`);
+            }
+        }
+        withTokenCount(message) {
+            return {
+                ...message,
+                tokenCount: this.estimateTokenCount(message),
+            };
+        }
+        estimateTokenCount(message) {
+            return estimateTokenCount(message, this.options.charsPerToken);
+        }
+        toModelMessage(msg, index, messages) {
+            const { tokenCount, ...message } = msg;
+            if (message.role === "system") {
+                return { ...message, role: "system" };
+            }
+            if (message.role === "assistant") {
+                // repair any broken tool-uses
+                this.repairBrokenToolCalls(message, index, messages);
+                return {
+                    ...prependReasoningBlockIfNeeded(message),
+                    role: "assistant",
+                };
+            }
+            if (message.role === "tool") {
+                const content = Array.isArray(message.content)
+                    ? message.content.map((part) => {
+                        if (part.type === "tool-result" &&
+                            typeof part.output === "object" &&
+                            part.output !== null) {
+                            const serialized = safeJsonStringify(part.output);
+                            const parsed = JSON.parse(serialized);
+                            const normalized = normalizeToolResultOutput(parsed);
+                            return { ...part, output: normalized };
+                        }
+                        return part;
+                    })
+                    : message.content;
+                return { ...message, content, role: "tool" };
+            }
+            return { ...message, role: "user" };
+        }
+        /**
+         * Removes tool-call parts from assistant messages if their results aren't present later in the context.
+         * This can happen if a tool call was made but the tool result message was never added (e.g. due to an error).
+         * Such orphaned tool calls trigger an error in some LLMs.
+         * Example error from Vertex:
+         *{ "type": "invalid_request_error", "message": "messages.2: `tool_use` ids were found without `tool_result` blocks immediately after: toolu_vrtx_014CKoGtt5B94Q4MwZZHZ8LU. Each `tool_use` block must have a corresponding `tool_result` block in the next message."}
+         */
+        repairBrokenToolCalls(assistant, index, messages) {
+            if (typeof assistant.content === "string") {
+                return;
+            }
+            const toolResultIds = new Set();
+            const toolCallIds = assistant.content.flatMap((part) => {
+                if (part.type === "tool-call") {
+                    return part.toolCallId;
+                }
+                else if (part.type === "tool-result") {
+                    toolResultIds.add(part.toolCallId);
+                }
+                return [];
+            });
+            if (toolCallIds.length === 0) {
+                return;
+            }
+            for (let i = index + 1; i < messages.length; i++) {
+                const msg = messages[i];
+                if (!msg || !(msg.role === "assistant" || msg.role === "tool")) {
+                    break;
+                }
+                if (typeof msg.content === "string") {
+                    break;
+                }
+                msg.content.forEach((part) => {
+                    if (part.type === "tool-result") {
+                        toolResultIds.add(part.toolCallId);
+                    }
+                });
+            }
+            assistant.content = assistant.content.filter((part) => {
+                if (part.type === "tool-call") {
+                    return toolResultIds.has(part.toolCallId);
+                }
+                return true;
+            });
+        }
+        /**
+         * Serializes context for persistence.
+         */
+        toRecord() {
+            return {
+                charsPerToken: this.options.charsPerToken,
+                l1Turns: this.l1Turns.map((turn) => turn.toRecord()),
+                l2Turns: this.l2Turns.map((turn) => turn.toRecord()),
+                l3Turns: this.l3Turns.map((turn) => turn.toRecord()),
+            };
+        }
+        printState(params = {}) {
+            if (this.logging.visualization.mode === "off")
+                return;
+            console.log(this.render(params));
+        }
+        /**
+         * Returns an ASCII representation of the context.
+         */
+        render(params = {}) {
+            return renderContext(this, params);
+        }
+        /**
+         * Deserializes a context from a record.
+         *
+         * @param record - Serialized context data
+         * @param params - Parameters for the context constructor
+         */
+        static fromRecord(record, params) {
+            const { id, options = {}, logging, onPersist, cacheStrategy } = params;
+            const context = new Context({
+                id,
+                options: {
+                    ...options,
+                    // restore persisted charsPerToken estimate
+                    charsPerToken: record.charsPerToken,
+                },
+                logging,
+                onPersist,
+                cacheStrategy,
+            });
+            context.l1Turns = record.l1Turns.map((turn) => L1Turn.fromRecord(turn));
+            context.l2Turns = record.l2Turns.map((turn) => L2Turn.fromRecord(turn));
+            context.l3Turns = record.l3Turns.map((turn) => L3Turn.fromRecord(turn));
+            return context;
+        }
+    };
+})();
+export { Context };
+//# sourceMappingURL=context.js.map