@xalia/agent 0.5.8 → 0.6.1

package/dist/agent/src/chat/data/dbMcpServerConfigs.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbMcpServerConfigs = void 0;
+const database_1 = require("./database");
+class DbMcpServerConfigs extends database_1.DbClientBase {
+    async clearConfigsForUser(user_uuid) {
+        const { error } = await this.client
+            .from("user_server_configs")
+            .delete()
+            .eq("user_uuid", user_uuid);
+        if (error) {
+            throw error;
+        }
+    }
+    async deleteConfigForUser(user_uuid, server_name) {
+        const { error } = await this.client
+            .from("user_server_configs")
+            .delete()
+            .eq("user_uuid", user_uuid)
+            .eq("server_name", server_name);
+        if (error) {
+            throw error;
+        }
+    }
+    async getConfigForUser(user_uuid, server_name) {
+        const { error, data } = await this.client
+            .from("user_server_configs")
+            .select("config")
+            .eq("user_uuid", user_uuid)
+            .eq("server_name", server_name)
+            .maybeSingle();
+        if (error) {
+            throw error;
+        }
+        return data ? data.config : undefined;
+    }
+    async setConfigForUser(user_uuid, server_name, config) {
+        const payload = { user_uuid, server_name, config };
+        const { error } = await this.client
+            .from("user_server_configs")
+            .upsert([payload], { onConflict: "user_uuid,server_name" });
+        if (error) {
+            throw error;
+        }
+    }
+}
+exports.DbMcpServerConfigs = DbMcpServerConfigs;

package/dist/agent/src/chat/protocol/connectionMessages.js

@@ -0,0 +1,5 @@
+"use strict";
+//
+// Connection-level Client Messages
+//
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/agent/src/chat/protocol/constants.js

@@ -0,0 +1,50 @@
+"use strict";
+/**
+ * Protocol constants for the multi-session chat system
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_MESSAGE_SIZE = exports.CHAT_CLOSE_CODES = exports.MESSAGE_PROCESSING_TIMEOUT = exports.CONNECTION_READY_TIMEOUT = exports.DEFAULT_USER_MESSAGE_QUEUE_SIZE = exports.DEFAULT_MESSAGE_QUEUE_SIZE = exports.SERVER_VERSION = exports.CLIENT_VERSION = exports.PROTOCOL_VERSION = exports.AGENT_VERSION = void 0;
+/**
+ * Current version of the agent package
+ */
+exports.AGENT_VERSION = "0.5.9";
+/**
+ * Protocol version for WebSocket communication
+ */
+exports.PROTOCOL_VERSION = exports.AGENT_VERSION;
+/**
+ * Client version sent in connection handshake
+ */
+exports.CLIENT_VERSION = exports.AGENT_VERSION;
+/**
+ * Server version sent in connection handshake responses
+ */
+exports.SERVER_VERSION = exports.AGENT_VERSION;
+/**
+ * Default message queue limits
+ */
+exports.DEFAULT_MESSAGE_QUEUE_SIZE = 100;
+exports.DEFAULT_USER_MESSAGE_QUEUE_SIZE = 10;
+/**
+ * Connection timeouts (in milliseconds)
+ */
+exports.CONNECTION_READY_TIMEOUT = 2000; // 2 seconds
+exports.MESSAGE_PROCESSING_TIMEOUT = 10000; // 10 seconds
+/**
+ * WebSocket close codes used by the chat system
+ * see: https://datatracker.ietf.org/doc/html/rfc6455#section-7.4.1
+ */
+exports.CHAT_CLOSE_CODES = {
+    NORMAL_CLOSURE: 1000,
+    GOING_AWAY: 1001,
+    PROTOCOL_ERROR: 1002,
+    INVALID_DATA: 1007,
+    // 4000-4999: application-defined error codes
+    AUTH_FAILED: 4003,
+    SESSION_ERROR: 4402,
+    RATE_LIMITED: 4403,
+};
+/**
+ * Maximum message size in bytes
+ */
+exports.MAX_MESSAGE_SIZE = 64 * 1024; // 64KB

package/dist/agent/src/chat/protocol/errors.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserAlreadyConnected = exports.ChatErrorMessage = exports.ChatFatalError = void 0;
+/**
+ * An error resulting the the connection being closed
+ */
+class ChatFatalError extends Error {
+}
+exports.ChatFatalError = ChatFatalError;
+/**
+ * An error to be reported, but not resulting in termination of the
+ * connection.
+ */
+class ChatErrorMessage extends Error {
+}
+exports.ChatErrorMessage = ChatErrorMessage;
+class UserAlreadyConnected extends ChatFatalError {
+    constructor() {
+        super("User already connected to the conversation");
+    }
+}
+exports.UserAlreadyConnected = UserAlreadyConnected;

package/dist/agent/src/chat/protocol/messages.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isClientControlMessage = isClientControlMessage;
+exports.isServerControlMessage = isServerControlMessage;
+exports.isServerSessionScopedMessage = isServerSessionScopedMessage;
+exports.decodeAssistantMessageParam = decodeAssistantMessageParam;
+function isClientControlMessage(message) {
+    const msg = message;
+    switch (msg.type) {
+        case "control_agent_profile_create":
+        case "control_agent_profile_delete":
+        case "control_get_session_list":
+        case "control_session_create":
+        case "control_session_delete":
+        case "control_session_join":
+        case "control_team_create":
+        case "control_add_team_user":
+        case "control_remove_team_user":
+            return true;
+        default: {
+            const _ = msg;
+            return false;
+        }
+    }
+}
+//
+// Type guard helper functions
+//
+function isServerControlMessage(message) {
+    const msg = message;
+    switch (msg.type) {
+        case "control_agent_profile_created":
+        case "control_agent_profile_deleted":
+        case "control_session_list":
+        case "control_session_left":
+        case "control_session_deleted":
+        case "control_team_created":
+        case "control_error":
+            return true;
+        default: {
+            const _ = msg;
+            return false;
+        }
+    }
+}
+/**
+ * Type guard to check if a ServerToClient message is a session-scoped message
+ */
+function isServerSessionScopedMessage(message) {
+    const msg = message;
+    switch (msg.type) {
+        case "session_error":
+        case "session_info":
+        case "user_msg":
+        case "agent_msg":
+        case "agent_msg_chunk":
+        case "user_joined":
+        case "user_left":
+        case "session_update":
+        case "tool_auto_approval_set":
+        case "tool_call":
+        case "tool_call_approval_result":
+        case "tool_call_result":
+        case "authentication_started":
+        case "authentication_finished":
+        case "user_typing":
+        case "mcp_server_added":
+        case "mcp_server_removed":
+        case "mcp_server_tool_enabled":
+        case "mcp_server_tool_disabled":
+        case "system_prompt_updated":
+        case "model_updated":
+        case "user_added":
+        case "user_removed":
+        case "authenticate":
+        case "approve_tool_call":
+        case "render_html":
+            return true;
+        default: {
+            const _ = msg;
+            return false;
+        }
+    }
+}
+function decodeAssistantMessageParam(msg) {
+    let text = "";
+    if (msg.audio) {
+        throw new Error("decodeAssistantMessageParam; audio unimplemented");
+    }
+    if (msg.content) {
+        if (typeof msg.content === "string") {
+            text = msg.content;
+        }
+        else if (msg.content instanceof Array) {
+            for (const c of msg.content) {
+                switch (c.type) {
+                    case "text":
+                        text += c.text;
+                        break;
+                    case "refusal":
+                        text += c.refusal;
+                        break;
+                    default:
+                        throw Error("unexpected AssistantMessageParam.content entry");
+                }
+            }
+        }
+    }
+    return text;
+}

package/dist/agent/src/chat/server/chatContextManager.js

@@ -0,0 +1,405 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatContextManager = void 0;
+exports.resolveConversationWithCheckpoint = resolveConversationWithCheckpoint;
+const assert_1 = require("assert");
+const sdk_1 = require("@xalia/xmcp/sdk");
+const agent_1 = require("../../agent/agent");
+const compressingContextManager_1 = require("../../agent/compressingContextManager");
+const conversation_1 = require("./conversation");
+const sessionFileManager_1 = require("./sessionFileManager");
+const logger = (0, sdk_1.getLogger)();
+/**
+ * TODO: Until token-tracking is in place.
+ */
+const COMPRESSION_TRIGGER_NUM_MESSAGES = parseInt(process.env["COMPRESSION_TRIGGER_NUM_MESSAGES"] || "80", 10);
+/**
+ * A context manager for Agents interacting with the (potentially multi-user)
+ * chat conversations.
+ *
+ * - Recreate an LLM context from message history + checkpoints
+ *
+ * - Maintain a compressing LLM context, and generate new checkpoints
+ *
+ * - Maintain pending user messages, agent loop messages and messages to be
+ *   committed to the DB
+ */
+class ChatContextManager {
+    constructor(systemPrompt, sessionMessages, sessionUUID, defaultUserName, checkpoint = undefined, compressionAgentUrl, compressionAgentModel, compressionAgentApiKey, checkpointWriter, fileManager) {
+        const nextMessageIdx = (0, conversation_1.sessionMessagesToNextIndex)(sessionMessages);
+        const { messages: llmMessages } = resolveConversationWithCheckpoint(sessionMessages, checkpoint);
+        logger.debug(`[ChatContextManager]: llm messages: ${JSON.stringify(llmMessages)}`);
+        // Insert a system message placeholder into the context
+        this.sessionUUID = sessionUUID;
+        this.conversationMessages = (0, conversation_1.sessionMessagesToChatMessages)(sessionMessages, defaultUserName, sessionUUID);
+        this.pendingUserMessages = [];
+        this.llmContext = new compressingContextManager_1.CompressingContextManager(systemPrompt, llmMessages, compressionAgentUrl, compressionAgentModel, compressionAgentApiKey);
+        this.nextMessageIdx = nextMessageIdx;
+        this.startingLLMContextLength = undefined;
+        this.curAgentMsgIdx = undefined;
+        this.pendingMessages = undefined;
+        this.pendingCompression = false;
+        this.checkpointWriter = checkpointWriter;
+        this.fileManager = fileManager;
+        fileManager.setEventHandler(this);
+        this.fileManagerDescriptionsDirty = true;
+    }
+    // IContextManager.addMessages
+    addMessages(messages) {
+        this.llmContext.addMessages(messages);
+    }
+    // IContextManager.addMessage
+    addMessage(message) {
+        this.llmContext.addMessage(message);
+    }
+    // IContextManager.getLLMContext
+    getLLMContext() {
+        if (this.fileManagerDescriptionsDirty) {
+            const filesSummary = (0, sessionFileManager_1.listFilesForLLM)(this.fileManager);
+            logger.debug(`[ChatContextManager] filemanager summary:\n${filesSummary}`);
+            this.llmContext.setPromptFragment("file_manager", filesSummary);
+            this.fileManagerDescriptionsDirty = false;
+        }
+        return this.llmContext.getLLMContext();
+    }
+    // IContextManager.getAgentPrompt
+    getAgentPrompt() {
+        return this.llmContext.getAgentPrompt();
+    }
+    // IContextManager.setAgentPrompt
+    setAgentPrompt(prompt) {
+        this.llmContext.setAgentPrompt(prompt);
+    }
+    // IContextManager.setPromptFragment
+    setPromptFragment(fragmentID, prompt) {
+        this.llmContext.setPromptFragment(fragmentID, prompt);
+    }
+    // IContextManager.removePromptFragment
+    removePromptFragment(fragmentID) {
+        this.llmContext.removePromptFragment(fragmentID);
+    }
+    // ISessionFileManagerEventHandler.onFileDescriptorChange
+    onFileDescriptorChange(_desc) {
+        this.fileManagerDescriptionsDirty = true;
+    }
+    // ISessionFileManagerEventHandler.onFileChange
+    onFileChange(_entry) {
+        this.fileManagerDescriptionsDirty = true;
+    }
+    setWorkspace(userMessage) {
+        this.llmContext.setWorkspace(userMessage);
+    }
+    getWorkspace() {
+        return this.llmContext.getWorkspace();
+    }
+    // Get the conversation (to send to clients)
+    getConversationMessages() {
+        return this.conversationMessages.concat(this.pendingUserMessages);
+    }
+    processUserMessage(msg, from) {
+        // TODO: maintain a queue internally instead of relying on the caller to
+        // pass in our generated messages back into `startAgentResponse`.
+        const message_idx = this.getNextMessageIdx();
+        const userMessage = {
+            type: "user_msg",
+            session_id: this.sessionUUID,
+            message_idx,
+            message: msg.message,
+            user_uuid: from,
+        };
+        if (msg.imageB64) {
+            userMessage.imageB64 = msg.imageB64;
+        }
+        this.pendingUserMessages.push(userMessage);
+        return userMessage;
+    }
+    unprocessUserMessage(userMsg) {
+        // TODO: when we maintain a queue, remove the entry from the queue.
+        this.freeMessageIdx(userMsg.message_idx);
+    }
+    // TODO: Don't take the set of messages.  Instead, have OpenSession or this
+    // class manage the interaction with the agent and ensure this process only
+    // happens one-at-a-time.
+    startAgentResponse(msgs) {
+        // Sanity check the state
+        (0, assert_1.strict)(typeof this.startingLLMContextLength === "undefined", "already processing");
+        (0, assert_1.strict)(typeof this.pendingMessages === "undefined", "already processing");
+        (0, assert_1.strict)(typeof this.curAgentMsgIdx === "undefined", "already processing");
+        // Sanity check the messages
+        const numMessages = this.pendingUserMessages.length;
+        (0, assert_1.strict)(numMessages > 0);
+        (0, assert_1.strict)(msgs.length === this.pendingUserMessages.length);
+        (0, assert_1.strict)(msgs[0].message_idx === this.pendingUserMessages[0].message_idx);
+        (0, assert_1.strict)(msgs[numMessages - 1].message_idx ===
+            this.pendingUserMessages[numMessages - 1].message_idx);
+        // Collect the pending user messages and allocate a starting index for
+        // agent messages and tool calls.
+        const pendingUserMessages = this.pendingUserMessages;
+        this.pendingUserMessages = [];
+        this.startingLLMContextLength = this.llmContext.getCommittedLength();
+        this.curAgentMsgIdx = this.getNextMessageIdx();
+        this.pendingMessages = pendingUserMessages;
+        // Compute the new llm messages
+        const llmUserMessages = [];
+        for (const msg of pendingUserMessages) {
+            const userMsg = (0, agent_1.createUserMessage)(msg.message, msg.imageB64, msg.user_uuid);
+            if (userMsg) {
+                llmUserMessages.push(userMsg);
+            }
+        }
+        return {
+            llmUserMessages,
+            agentFirstChunk: {
+                type: "agent_msg_chunk",
+                session_id: this.sessionUUID,
+                message_idx: this.curAgentMsgIdx,
+                message: "",
+                end: false,
+            },
+        };
+    }
+    endAgentResponse() {
+        (0, assert_1.strict)(typeof this.startingLLMContextLength !== "undefined");
+        (0, assert_1.strict)(typeof this.pendingMessages !== "undefined");
+        (0, assert_1.strict)(typeof this.curAgentMsgIdx !== "undefined");
+        const numPending = this.pendingMessages.length;
+        (0, assert_1.strict)(numPending > 1); // 1 user + 1 agent message
+        // Compute DB messages
+        const newSessionMessages = (0, conversation_1.chatMessagesToSessionMessages)(this.pendingMessages);
+        const newLLMMessages = this.llmContext.getPending();
+        const messageListError = (error) => {
+            throw new Error(`${error}:` +
+                `\n  newSessionMessages: ${JSON.stringify(newSessionMessages)}` +
+                `\n  this.pendingMessages: ${JSON.stringify(this.pendingMessages)}` +
+                `\n  newLLMMessages: ${JSON.stringify(newLLMMessages)}`);
+        };
+        if (newSessionMessages.length !== numPending) {
+            messageListError("newSessionMessages.length !== numPending");
+        }
+        if (newLLMMessages.length !== numPending) {
+            messageListError("newLLMMessages.length !== numPending");
+        }
+        // The SessionMessages should satisfy:
+        //  - sMsg.message_idx === pMsg.message_idx
+        //  - sMsg.content === llmMsg
+        // this ensures all representations are aligned.
+        for (let i = 0; i < numPending; ++i) {
+            const sMsg = newSessionMessages[i];
+            const pMsg = this.pendingMessages[i];
+            const lMsg = newLLMMessages[i];
+            if (sMsg.content.role !== lMsg.role) {
+                messageListError(`newSessionMessages[${String(i)}].role !== ` +
+                    `newLLMMessages[${String(i)}].role`);
+            }
+            if (JSON.stringify(sMsg.content) !== JSON.stringify(lMsg)) {
+                messageListError(`newSessionMessages[${String(i)}].content !== ` +
+                    `newLLMMessages[${String(i)}].content`);
+            }
+            if (sMsg.message_idx !== pMsg.message_idx) {
+                messageListError(`newSessionMessages[${String(i)}].message_idx !== ` +
+                    `pendingMessages[${String(i)}].message_idx`);
+            }
+        }
+        // Update our internal state and return the SessionMessages to write to
+        // the DB
+        this.llmContext.commit();
+        this.conversationMessages.push(...this.pendingMessages);
+        this.startingLLMContextLength = undefined;
+        this.pendingMessages = undefined;
+        this.curAgentMsgIdx = undefined;
+        // Kick off a compression?
+        this.checkCompression();
+        return newSessionMessages;
+    }
+    /**
+     * End the Agent message session with an error.  Caller should not call
+     * `endAgentResponse` after calling this function.
+     *
+     * This function checks that nothing has been entered into the LLM context,
+     * and drops any new user messages or responses before the error.
+     */
+    revertAgentResponse(errMsg) {
+        logger.warn(`[ChatContextManager.revertAgentResponse] error: ${errMsg}`);
+        (0, assert_1.strict)(typeof this.startingLLMContextLength !== "undefined");
+        (0, assert_1.strict)(typeof this.pendingMessages !== "undefined");
+        (0, assert_1.strict)(typeof this.curAgentMsgIdx !== "undefined");
+        // Sanity check that no new messages were put into the context (The Agent
+        // is expected to only call `addMessage(s)` at the end of the Agent loop.
+        // (Note, we don't check for equality here, just in case the context was
+        // compressed while the Agent was executing).
+        const contextLength = this.llmContext.getCommittedLength();
+        if (contextLength > this.startingLLMContextLength) {
+            logger.error("[ChatContextManager.revertAgentResponse] llmContext has grown " +
+                `despite Agent error (${String(contextLength)}, ` +
+                `${String(this.startingLLMContextLength)})`);
+        }
+        // We simply reset the state, dropping any pending messages.
+        this.startingLLMContextLength = undefined;
+        this.pendingMessages = undefined;
+        this.curAgentMsgIdx = undefined;
+        return {
+            type: "session_error",
+            session_id: this.sessionUUID,
+            message: errMsg,
+        };
+    }
+    processAgentMessage(msg, end) {
+        (0, assert_1.strict)(typeof this.startingLLMContextLength !== "undefined");
+        (0, assert_1.strict)(typeof this.pendingMessages !== "undefined");
+        (0, assert_1.strict)(typeof this.curAgentMsgIdx !== "undefined");
+        const message = {
+            type: "agent_msg_chunk",
+            session_id: this.sessionUUID,
+            message_idx: this.getCurrentAgentMessageIdx(),
+            message: msg,
+            end,
+        };
+        return message;
+    }
+    /**
+     * Process a FULL Agent message (not chunks from stream).  No message is
+     * required for broadcast as the calling code is expected to broadcast this
+     * as chunks.
+     */
+    processAgentResponse(result) {
+        (0, assert_1.strict)(typeof this.startingLLMContextLength !== "undefined");
+        (0, assert_1.strict)(typeof this.pendingMessages !== "undefined");
+        (0, assert_1.strict)(typeof this.curAgentMsgIdx !== "undefined");
+        // Insert this (full) agent response into the list of agent messages
+        const msg = {
+            type: "agent_msg",
+            session_id: this.sessionUUID,
+            message_idx: this.getNextMessageSubIdx(),
+            message: result,
+        };
+        this.pendingMessages.push(msg);
+    }
+    processToolCallResult(result) {
+        (0, assert_1.strict)(typeof this.startingLLMContextLength !== "undefined");
+        (0, assert_1.strict)(typeof this.pendingMessages !== "undefined");
+        (0, assert_1.strict)(typeof this.curAgentMsgIdx !== "undefined");
+        // Allocate the sub-index for this tool call result.  It should not
+        // have been used already.
+        const message_idx = this.getNextMessageSubIdx();
+        const numPending = this.pendingMessages.length;
+        (0, assert_1.strict)(numPending > 0);
+        (0, assert_1.strict)(this.pendingMessages[numPending - 1].message_idx < message_idx);
+        const msg = {
+            type: "tool_call_result",
+            session_id: this.sessionUUID,
+            message_idx,
+            result,
+        };
+        this.pendingMessages.push(msg);
+        return msg;
+    }
+    getNextMessageIdx() {
+        const idx = this.nextMessageIdx;
+        this.nextMessageIdx += conversation_1.MESSAGE_INDEX_FULL_INCREMENT;
+        return idx;
+    }
+    /**
+     * Only reuse it if no other indices have been allocated.  It's the callers
+     * responsibility to ensure this.
+     */
+    freeMessageIdx(messageIdx) {
+        (0, assert_1.strict)(messageIdx === this.nextMessageIdx - conversation_1.MESSAGE_INDEX_FULL_INCREMENT, "message idx cannot be free-ed");
+        this.nextMessageIdx = messageIdx;
+    }
+    /// Get the current index to use for streaming Agent chunks
+    getCurrentAgentMessageIdx() {
+        (0, assert_1.strict)(typeof this.pendingMessages !== "undefined");
+        (0, assert_1.strict)(typeof this.curAgentMsgIdx !== "undefined");
+        return this.curAgentMsgIdx;
+    }
+    getNextMessageSubIdx() {
+        (0, assert_1.strict)(typeof this.pendingMessages !== "undefined");
+        (0, assert_1.strict)(typeof this.curAgentMsgIdx !== "undefined");
+        const idx = this.curAgentMsgIdx;
+        this.curAgentMsgIdx += conversation_1.MESSAGE_INDEX_SUB_INCREMENT;
+        return idx;
+    }
+    checkCompression() {
+        if (this.pendingCompression) {
+            return;
+        }
+        // TODO: track tokens and use that to trigger compression
+        const numCommitted = this.llmContext.getCommittedLength();
+        if (numCommitted < COMPRESSION_TRIGGER_NUM_MESSAGES) {
+            return;
+        }
+        void this.runCompression();
+    }
+    async runCompression() {
+        (0, assert_1.strict)(!this.pendingCompression);
+        this.pendingCompression = true;
+        const checkpointIndex = this.conversationMessages[this.conversationMessages.length - 1]
+            .message_idx;
+        try {
+            const summary = await this.llmContext.compress();
+            const checkpoint = {
+                message_idx: checkpointIndex,
+                summary,
+            };
+            await this.checkpointWriter.writeCheckpoint(checkpoint);
+        }
+        catch (err) {
+            logger.warn(`[runCompression] error during compression: ${JSON.stringify(err)}`);
+        }
+        finally {
+            this.pendingCompression = false;
+        }
+    }
+}
+exports.ChatContextManager = ChatContextManager;
+function resolveConversationWithCheckpoint(messages, checkpoint) {
+    const numMessages = messages.length;
+    let lastEntryIdx = 0;
+    if (numMessages !== 0) {
+        lastEntryIdx = messages[numMessages - 1].message_idx;
+    }
+    // Only keep the messages we care about
+    messages = messages.filter((msg) => msg.is_for_llm);
+    // If no checkpoint, return all messages
+    if (!checkpoint) {
+        return {
+            messages: messages.map((msg) => msg.content),
+            lastEntryIdx,
+        };
+    }
+    // Find the first entry in messages s.t. entry.message_idx >
+    // checkpoint.message_idx
+    const checkpointIdx = checkpoint.message_idx;
+    const keepIdx = (() => {
+        let idx = numMessages - 1;
+        while (idx >= 0) {
+            if (messages[idx].message_idx <= checkpointIdx) {
+                break;
+            }
+            idx--;
+        }
+        // Idx points to the first entry (from the end) with message_idx <=
+        // checkpointIdx, so the first entry with message_idx > checkpointIdx is
+        // idx+1 and We can then extract the required messages with
+        //
+        //   message.slice(idx+1)
+        //
+        // Edge-cases:
+        //
+        // - loop exhausted, idx = -1, we want slice(0 = idx+1) (all messages)
+        //
+        // - loop exited on first entry (all entries are contained in the
+        //   checkpoint), idx = numMessages - 1, we want
+        //   slice(numMessages = idx + 1)
+        return idx + 1;
+    })();
+    const checkpointMessage = (0, compressingContextManager_1.createCheckpointMessage)(checkpoint.summary);
+    const llmMessages = [
+        checkpointMessage,
+        ...messages.slice(keepIdx).map((msg) => msg.content),
+    ];
+    return {
+        messages: llmMessages,
+        lastEntryIdx: Math.max(lastEntryIdx, checkpoint.message_idx),
+    };
+}