@xalia/agent 0.6.8 → 0.6.10

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

@@ -1,10 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OpenSession = exports.ChatSessionAgentEventHandler = exports.ChatSessionMessageSender = exports.GUEST_TOKEN_PREFIX = exports.DEFAULT_NUM_MESSGAES = void 0;
+exports.OpenSession = exports.ChatSessionAgentEventHandler = exports.ChatSessionMessageSender = exports.RACE_MODE_TIMEOUT_MS = exports.GUEST_TOKEN_PREFIX = exports.DEFAULT_NUM_MESSGAES = void 0;
 const assert_1 = require("assert");
+const uuid_1 = require("uuid");
 const sdk_1 = require("@xalia/xmcp/sdk");
 const agent_1 = require("../../agent/agent");
+const sudoMcpServerManager_1 = require("../../agent/sudoMcpServerManager");
 const agentUtils_1 = require("../../agent/agentUtils");
+const titleGenerator_1 = require("./titleGenerator");
 const asyncQueue_1 = require("../utils/asyncQueue");
 const multiAsyncQueue_1 = require("../utils/multiAsyncQueue");
 const database_1 = require("../data/database");
@@ -14,11 +17,16 @@ const tools_1 = require("./tools");
 const chatContextManager_1 = require("./chatContextManager");
 const conversation_1 = require("./conversation");
 const sessionFileManager_1 = require("./sessionFileManager");
+const fileManager_1 = require("../../agent/tools/fileManager");
+const pdfToText_1 = require("../../agent/tools/contentExtractors/pdfToText");
+const documentSummarizer_1 = require("../../agent/documentSummarizer");
 const errorUtils_1 = require("./errorUtils");
 const nodePlatform_1 = require("../../tool/nodePlatform");
 const dbMcpServerConfigs_1 = require("../data/dbMcpServerConfigs");
 const apiKeyManager_1 = require("../data/apiKeyManager");
 const dbSessionMessages_1 = require("../data/dbSessionMessages");
+const openAIRouterLLM_1 = require("./openAIRouterLLM");
+const responseAwaiter_1 = require("../utils/responseAwaiter");
 /**
  * The model to use when the AgentProfile does not specify one.
  */
@@ -28,6 +36,7 @@ const DEFAULT_CHAT_LLM_MODEL = process.env["DEFAULT_LLM_MODEL"] || "anthropic/cl
  */
 exports.DEFAULT_NUM_MESSGAES = 500;
 exports.GUEST_TOKEN_PREFIX = "guest";
+exports.RACE_MODE_TIMEOUT_MS = 120000;
 const logger = (0, sdk_1.getLogger)();
 /**
  * Implementation of ICheckpointWriter that writes into the DB.
@@ -109,24 +118,25 @@ class ChatSessionPlatform {
     }
 }
 class ChatSessionAgentEventHandler {
-    constructor(sessionUUID, sender, approvalManager, contextManager) {
+    constructor(sessionUUID, sender, approvalManager, contextTx, alt) {
         this.sessionUUID = sessionUUID;
         this.sender = sender;
         this.approvalManager = approvalManager;
-        this.contextManager = contextManager;
+        this.contextTx = contextTx;
+        this.alt = alt;
     }
     onCompletion(result) {
-        logger.debug(`[OpenSession.onCompletion] : ${JSON.stringify(result)}`);
+        logger.debug(`[OpenSession.onCompletion] ${this.alt || ""} : ${JSON.stringify(result)}`);
         // Nothing to broadcast. Caller will receive this via onAgentMessage.
-        this.contextManager.processAgentResponse(result);
+        this.contextTx.processAgentResponse(result);
     }
     onImage(image) {
-        logger.debug(`[OpenSession.onImage] : ${image.image_url.url}`);
+        logger.debug(`[OpenSession.onImage] ${this.alt || ""} : ${image.image_url.url}`);
         throw new Error("[OpenSession.onImage] unimplemented");
     }
     onToolCallResult(result) {
-        logger.debug(`[onToolCallResult] : ${JSON.stringify(result)}`);
-        const toolCallMessage = this.contextManager.processToolCallResult(result);
+        logger.debug(`[onToolCallResult] ${this.alt || ""} : ${JSON.stringify(result)}`);
+        const toolCallMessage = this.contextTx.processToolCallResult(result);
         this.sender.broadcast(toolCallMessage);
     }
     async onToolCall(toolCall, agentTool) {
@@ -137,12 +147,13 @@ class ChatSessionAgentEventHandler {
                 type: "tool_call",
                 tool_call: toolCall,
                 session_id: this.sessionUUID,
+                ...(this.alt ? { alt: this.alt } : {}),
             });
             return true;
         }
         // TODO: Need a proper mapping to/from MCP calls to tool names
         const [serverName, tool] = toolCall.function.name.split("__");
-        const { approved, requested } = await this.approvalManager.getApproval(serverName, tool, toolCall);
+        const { approved, requested } = await this.approvalManager.getApproval(serverName, tool, toolCall, this.alt);
         // For now, the frontend uses the tool_call data in the
         // "approve_tool_call" request to display the tool call data.  If approval
         // was requested in this way, don't send the "tool_call" message as well.
@@ -151,25 +162,31 @@ class ChatSessionAgentEventHandler {
                 type: "tool_call",
                 tool_call: toolCall,
                 session_id: this.sessionUUID,
+                ...(this.alt ? { alt: this.alt } : {}),
             });
         }
         return approved;
     }
     onAgentMessage(msg, end) {
-        logger.debug(`[OpenSession.onAgentMessage] msg: ${msg}, end: ${String(end)}`);
+        logger.debug(`[OpenSession.onAgentMessage] ${this.alt || ""} msg: ${msg}, ` +
+            `end: ${String(end)}`);
         // Inform the contextManager and broadcast the ServerAgentMessageChunk
-        const agentMsgChunk = this.contextManager.processAgentMessage(msg, end);
+        const agentMsgChunk = this.contextTx.processAgentMessageChunk(msg, end);
+        if (this.alt) {
+            agentMsgChunk.alt = this.alt;
+        }
         this.sender.broadcast(agentMsgChunk);
         return Promise.resolve();
     }
     onReasoning(reasoning) {
         return new Promise((r) => {
-            logger.debug(`[OpenSession.onReasoning]${reasoning}`);
+            logger.debug(`[OpenSession.onReasoning] ${this.alt || ""} ${reasoning}`);
             if (reasoning.length > 0) {
                 this.sender.broadcast({
                     type: "agent_reasoning_chunk",
                     reasoning,
                     session_id: this.sessionUUID,
+                    ...(this.alt ? { alt: this.alt } : {}),
                 });
             }
             r();
@@ -188,7 +205,7 @@ exports.ChatSessionAgentEventHandler = ChatSessionAgentEventHandler;
  * tool approvals and other interactions).
  */
 class OpenSession {
-    constructor(db, agent, sessionData, savedAgentProfile, isPersisted, sessionParticipants, agentProfilePreferences, skillManager, contextManager, sender, approvalManager, fileManager) {
+    constructor(db, agent, sessionData, savedAgentProfile, isPersisted, sessionParticipants, agentProfilePreferences, skillManager, contextManager, sender, approvalManager, fileManager, platform) {
         this.db = db;
         this.agent = agent;
         this.sessionUUID = sessionData.session_uuid;
@@ -206,25 +223,29 @@ class OpenSession {
         this.approvalManager = approvalManager;
         this.savedAgentProfile = savedAgentProfile;
         this.sessionFileManager = fileManager;
+        this.platform = platform;
+        this.raceModeAwaiter = responseAwaiter_1.ResponseAwaiter.init(undefined, (m) => m.message_id, exports.RACE_MODE_TIMEOUT_MS);
         this.isPersisted = isPersisted;
         this.sessionTitle = sessionData.title;
         this.sessionUpdatedAt = sessionData.updated_at;
         this.agentPaused = sessionData.agent_paused;
+        this.titleGenerator = (0, titleGenerator_1.createTitleGenerator)();
         fileManager.addEventHandler(this);
         this.updateParticipantsPrompt();
     }
-    static async init(db, isPersisted, sessionData, savedAgentProfile, sessionMessages, sessionParticipants, ownerData, ownerApiKey, sessionCheckpoint, llmUrl, xmcpUrl, connectionManager) {
+    static async init(db, isPersisted, sessionData, savedAgentProfile, sessionMessages, sessionParticipants, ownerData, ownerApiKey, sessionCheckpoint, xmcpUrl, connectionManager) {
         const sessionId = sessionData.session_uuid;
         const fileManager = await sessionFileManager_1.ChatSessionFileManager.init(db, sessionId);
         const sender = new ChatSessionMessageSender(connectionManager, sessionParticipants);
         const platform = new ChatSessionPlatform(sender, sessionId, ownerData.uuid);
         const toolApprovalManager = new approvalManager_1.ToolApprovalManager(sessionData.session_uuid, savedAgentProfile.uuid, savedAgentProfile.preferences, sender, new approvalManager_1.DbAgentPreferencesWriter(db));
-        const { agent, skillManager, contextManager } = await createContextAndAgent(sessionId, savedAgentProfile.profile.system_prompt, savedAgentProfile.profile.model || DEFAULT_CHAT_LLM_MODEL, sessionMessages, sessionData.workspace, sessionCheckpoint, ownerData, ownerApiKey, llmUrl, xmcpUrl, fileManager, sender, platform, toolApprovalManager);
-        const openSession = new OpenSession(db, agent, sessionData, savedAgentProfile, isPersisted, sessionParticipants, savedAgentProfile.preferences, skillManager, contextManager, sender, toolApprovalManager, fileManager);
+        const checkpointWriter = new DBCheckpointWriter(db, sessionId);
+        const { agent, skillManager, contextManager } = await createContextAndAgent(sessionId, savedAgentProfile.profile.system_prompt, savedAgentProfile.profile.model || DEFAULT_CHAT_LLM_MODEL, sessionMessages, sessionData.workspace, sessionCheckpoint, ownerData, ownerApiKey, xmcpUrl, fileManager, platform, checkpointWriter, sender);
+        const openSession = new OpenSession(db, agent, sessionData, savedAgentProfile, isPersisted, sessionParticipants, savedAgentProfile.preferences, skillManager, contextManager, sender, toolApprovalManager, fileManager, platform);
         // Note, MCP servers have not been enabled yet
         return openSession;
     }
-    static async initWithEmptySession(db, sessionData, llmUrl, xmcpUrl, connectionManager) {
+    static async initWithEmptySession(db, sessionData, xmcpUrl, connectionManager) {
         const sessionMessages = [];
         const sessionCheckpoint = undefined;
         const { savedAgentProfile, ownerData, ownerApiKey } = await loadDataForEmptySession(db, sessionData.agent_profile_uuid, sessionData.user_uuid);
@@ -245,12 +266,12 @@ class OpenSession {
                 role: "owner",
             });
         }
-        return OpenSession.init(db, false /* isPersisted */, sessionData, savedAgentProfile, sessionMessages, sessionParticipants, ownerData, ownerApiKey, sessionCheckpoint, llmUrl, xmcpUrl, connectionManager);
+        return OpenSession.init(db, false /* isPersisted */, sessionData, savedAgentProfile, sessionMessages, sessionParticipants, ownerData, ownerApiKey, sessionCheckpoint, xmcpUrl, connectionManager);
     }
-    static async initWithExistingSession(db, sessionId, llmUrl, xmcpUrl, connectionManager) {
+    static async initWithExistingSession(db, sessionId, xmcpUrl, connectionManager) {
         // Load session data from database
         const { sessionData, sessionMessages, sessionCheckpoint, savedAgentProfile, sessionParticipants, ownerData, ownerApiKey, } = await loadSessionData(db, sessionId);
-        return OpenSession.init(db, true /* isPersisted */, sessionData, savedAgentProfile, sessionMessages, sessionParticipants, ownerData, ownerApiKey, sessionCheckpoint, llmUrl, xmcpUrl, connectionManager);
+        return OpenSession.init(db, true /* isPersisted */, sessionData, savedAgentProfile, sessionMessages, sessionParticipants, ownerData, ownerApiKey, sessionCheckpoint, xmcpUrl, connectionManager);
     }
     onEmpty() {
         logger.info(`[OpenSession.onEmpty] session ${this.sessionUUID}`);
@@ -295,14 +316,16 @@ class OpenSession {
             });
         });
         // send conversation history
-        const conversationMessages = this.contextManager.getConversationMessages();
+        const conversationMessages = this.contextManager
+            .getConversationMessages()
+            .concat(this.userMessageQueue.getEntries());
         conversationMessages.forEach((message) => {
             connMgr.sendToConnection(connectionId, message);
         });
         // add MCP settings
         this.sendMcpSettings(connectionId);
         // add system prompt and model
-        const agentProfile = this.agent.getAgentProfile();
+        const agentProfile = this.getAgentProfile();
         connMgr.sendToConnection(connectionId, {
             type: "system_prompt_updated",
             system_prompt: agentProfile.system_prompt,
@@ -378,30 +401,25 @@ class OpenSession {
                 this.sender.broadcast(msg);
             }
         };
+        let errorMessage;
         if (err instanceof errors_1.ChatFatalError) {
             // ChatFatalError in session context should send error to specific user
             // or broadcast if no specific user context
-            sendError({
-                type: "session_error",
-                message: err.message,
-                session_id: this.sessionUUID,
-            });
+            errorMessage = err.message;
         }
         else if (err instanceof errors_1.ChatErrorMessage) {
-            sendError({
-                type: "session_error",
-                message: err.message,
-                session_id: this.sessionUUID,
-            });
+            errorMessage = err.message;
         }
         else {
-            const errString = (0, errorUtils_1.getErrorString)(err);
-            sendError({
-                type: "session_error",
-                message: errString,
-                session_id: this.sessionUUID,
-            });
+            errorMessage = (0, errorUtils_1.getErrorString)(err);
         }
+        logger.error(`[OpenSession.handleError] sessionUUID=${this.sessionUUID} ` +
+            `from=${from ?? "broadcast"}: ${errorMessage}`);
+        sendError({
+            type: "session_error",
+            message: errorMessage,
+            session_id: this.sessionUUID,
+        });
         return true;
     }
     // ISessionFileManagerEventHandler.onFileDeleted
@@ -412,6 +430,15 @@ class OpenSession {
             name,
         });
     }
+    broadcastContextUsage() {
+        const { used, max } = this.contextManager.getContextUsage();
+        this.sender.broadcast({
+            type: "context_usage",
+            session_id: this.sessionUUID,
+            used_tokens: used,
+            max_tokens: max,
+        });
+    }
     // ISessionFileManagerEventHandler.onFileChanged
     onFileChanged(entry, new_file) {
         this.sender.broadcast({
@@ -490,6 +517,9 @@ class OpenSession {
                 case "msg":
                     broadcastMsg = await this.handleUserMessage(msg, queuedMessage.from);
                     break;
+                case "stop":
+                    this.agent.stop();
+                    break;
                 case "add_mcp_server":
                     broadcastMsg = await this.handleAddMcpServer(msg.server_name, msg.enable_all);
                     break;
@@ -541,12 +571,12 @@ class OpenSession {
                 case "share_session":
                     await this.handleShareSession(msg, queuedMessage.from);
                     break;
-                case "add_mcp_server_from_url":
-                    void this.handleAddMcpServerFromUrl(msg, queuedMessage.from);
-                    break;
                 case "get_mcp_resource":
                     void this.handleGetMcpResource(msg, queuedMessage.from);
                     break;
+                case "race_mode_result":
+                    this.raceModeAwaiter.onMessage(msg);
+                    break;
                 default: {
                     const exhaustive = msg; // Error => non-exhaustive switch-case.
                     return exhaustive;
@@ -560,6 +590,10 @@ class OpenSession {
                 }
                 else {
                     this.sender.broadcast(broadcastMsg);
+                    // Broadcast context usage after user message
+                    if (broadcastMsg.type === "user_msg") {
+                        this.broadcastContextUsage();
+                    }
                 }
             }
         }
@@ -582,29 +616,6 @@ class OpenSession {
             session_id: this.sessionUUID,
         });
     }
-    async handleAddMcpServerFromUrl(msg, from) {
-        const skillManager = this.skillManager;
-        try {
-            const serverName = msg.server_name;
-            await skillManager.addMcpServerWithStreamableHTTPUrl(serverName, msg.url);
-            this.skillManager.enableAllTools(serverName);
-            const server = skillManager.getMcpServer(serverName);
-            const tools = server.getTools();
-            const resources = server.getResources();
-            const enabled_tools = Array.from(server.getEnabledTools().keys());
-            this.sender.broadcast({
-                type: "mcp_server_added",
-                server_name: serverName,
-                tools,
-                resources,
-                enabled_tools,
-                session_id: this.sessionUUID,
-            });
-        }
-        catch (err) {
-            this.handleError(err, from);
-        }
-    }
     async handleGetMcpResource(msg, from) {
         try {
             const contents = await this.skillManager.getResource(msg.server_name, msg.uri);
@@ -637,33 +648,103 @@ class OpenSession {
      * `processUserMessage` logic when agent is paused.  Trigger the context,
      * add the user messages and then extract the new DB messages.
      */
-    processUserMessagePaused(msgs) {
-        const { llmUserMessages } = this.contextManager.startAgentResponse(msgs);
-        // Just send the user LLM messages direct to the ContextManager, so they
-        // are available to the LLM once it is restarted.
-        this.contextManager.addMessages(llmUserMessages);
-        return this.contextManager.endAgentResponse();
+    async processUserMessagePaused(msgs) {
+        // Just send the user LLM user messages direct to the ContextManager, so
+        // they are available to the LLM once it is restarted.
+        const { contextTx } = await this.contextManager.startAgentResponse(msgs);
+        const result = this.contextManager.endAgentResponse(contextTx);
+        this.broadcastContextUsage();
+        return result;
     }
     async processUserMessagesActive(msgs) {
-        const { llmUserMessages, agentFirstChunk } = this.contextManager.startAgentResponse(msgs);
+        // All accumulated messages (DB, Protocol and LLM) should be on the
+        // specialized contextTx.
+        const { contextTx, agentFirstChunk } = await this.contextManager.startAgentResponse(msgs);
         this.sender.broadcast(agentFirstChunk);
+        const eventHandler = new ChatSessionAgentEventHandler(this.sessionUUID, this.sender, this.approvalManager, contextTx);
         try {
-            await this.agent.userMessagesRaw(llmUserMessages);
+            await this.agent.userMessagesRaw(contextTx, eventHandler);
         }
         catch (e) {
             logger.warn(`[OpenSession.processUserMessages] agent error: ${String(e)}`);
             // Errors during agent replies must be turned into messages.
             const errMsg = `error from LLM: ${String(e)}`;
-            this.contextManager.revertAgentResponse(errMsg);
+            contextTx.revertAgentResponse(errMsg);
+            // TODO: This will prevent the user messages from being saved in the
+            // DB.  Should we keep them?
             throw new Error(errMsg);
         }
-        return this.contextManager.endAgentResponse();
+        const result = this.contextManager.endAgentResponse(contextTx);
+        this.broadcastContextUsage();
+        return result;
+    }
+    /**
+     * `processUserMessage` logic for race-mode.
+     */
+    async processUserMessagesRaceMode(msgs) {
+        // Create a second agent, same skillManager
+        const modelB = msgs[0].race_mode;
+        (0, assert_1.strict)(typeof modelB === "string");
+        const agentB = await (async () => {
+            try {
+                const llmB = await createLLM(modelB, this.platform);
+                return new agent_1.AgentEx(this.skillManager, llmB);
+            }
+            catch (e) {
+                logger.warn("[OpenSession.processUserMessages] error creating race agent: " +
+                    String(e));
+                throw new Error(`error creating race: ${String(e)}`);
+            }
+        })();
+        const run = async (alt, msgs) => {
+            const { contextTx: contextTx, agentFirstChunk: agentFirstChunk } = await this.contextManager.startAgentResponse(msgs.slice());
+            this.sender.broadcast(agentFirstChunk);
+            const eventHandler = new ChatSessionAgentEventHandler(this.sessionUUID, this.sender, this.approvalManager, contextTx, alt);
+            try {
+                const agent = alt === "B" ? agentB : this.agent;
+                await agent.userMessagesRaw(contextTx, eventHandler);
+            }
+            catch (e) {
+                logger.warn(`[OpenSession.processUserMessages] agent ${alt} error: ${String(e)}`);
+                const errMsg = `error from LLM: ${String(e)}`;
+                contextTx.revertAgentResponse(errMsg);
+                throw new Error(errMsg);
+            }
+            return contextTx;
+        };
+        const [txA, txB] = await Promise.all([
+            run("A", msgs.slice()),
+            run("B", msgs),
+        ]);
+        // Ask which fork to commit
+        const answer = await (async () => {
+            const message_id = (0, uuid_1.v4)();
+            const answerP = this.raceModeAwaiter.waitForResponse(message_id);
+            const getResultMsg = {
+                type: "race_mode_get_result",
+                message_id,
+                alts: ["A", "B"],
+                session_id: this.sessionUUID,
+            };
+            this.sender.broadcast(getResultMsg);
+            return answerP;
+        })();
+        if (answer.result === "A") {
+            return this.contextManager.endAgentResponse(txA);
+        }
+        else {
+            return this.contextManager.endAgentResponse(txB);
+        }
+        // UI is responsible for switching model if the user wants to.
     }
     async processUserMessages(msgs) {
+        logger.debug(`[processUserMessages] msgs: ${JSON.stringify(msgs)}`);
         try {
             const newSessionMessages = this.agentPaused
-                ? this.processUserMessagePaused(msgs)
-                : await this.processUserMessagesActive(msgs);
+                ? await this.processUserMessagePaused(msgs)
+                : await (msgs[0].race_mode
+                    ? this.processUserMessagesRaceMode(msgs)
+                    : this.processUserMessagesActive(msgs));
             logger.debug("[processUserMessages] newSessionMessages: " +
                 JSON.stringify(newSessionMessages));
             // Append to in-memory conversation and write to the DB
@@ -671,6 +752,8 @@ class OpenSession {
             await dbsm.append(this.sessionUUID, newSessionMessages);
         }
         catch (e) {
+            logger.error(`[processUserMessages] ERROR session=${this.sessionUUID}: ` +
+                String(e));
             if (!this.handleError(e)) {
                 throw e;
             }
@@ -680,9 +763,16 @@ class OpenSession {
         // Return a ServerUserMessage for broadcast.  The actual message is places
         // on a queue to be dealt with in another loop.  This allows Agent
         // processing of user messages to depend on other messages.
-        (0, assert_1.strict)(msg);
-        (0, assert_1.strict)(from);
-        // Assign the user message_idx and attempt to enqueue.
+        (0, assert_1.strict)(msg, "undefined user message");
+        (0, assert_1.strict)(from, "undefined user message sender");
+        logger.info(`[handleUserMessage] msg.attachedFiles: ${JSON.stringify(msg.attachedFiles
+            ? msg.attachedFiles.map((f) => ({
+                name: f.name,
+                data_url_length: f.data_url.length,
+            }))
+            : "none")}`);
+        // Assign the user message_idx first so we can check if this is
+        // the first message
         const user = this.sessionParticipants.get(from);
         if (!user) {
             throw new Error(`unrecognized user ${from}`);
@@ -691,6 +781,62 @@ class OpenSession {
         if (!userMessage) {
             return;
         }
+        // Handle attached files by adding them to session files
+        if (msg.attachedFiles && msg.attachedFiles.length > 0) {
+            const fileCount = String(msg.attachedFiles.length);
+            logger.info(`[handleUserMessage] Processing ${fileCount} attached files`);
+            // If this is the first message, set the session title before
+            // creating the session
+            if (userMessage.message_idx === conversation_1.MESSAGE_INDEX_START_VALUE &&
+                !this.isPersisted) {
+                this.sessionTitle = userMessage.message?.slice(0, 128) || "New Chat";
+            }
+            // If the session hasn't been persisted, it must be written to
+            // the DB first
+            if (!this.isPersisted) {
+                await this.createSessionInDB();
+            }
+            // Add each attached file to session files
+            for (const file of msg.attachedFiles) {
+                logger.info(`[handleUserMessage] Adding file ${file.name} to session files`);
+                // Extract content and generate summary for PDFs
+                let parsed_content;
+                let summary;
+                const mimeType = (0, fileManager_1.getMimeTypeFromDataUrl)(file.data_url);
+                if (mimeType === "application/pdf") {
+                    try {
+                        // Extract base64 data and convert to ArrayBuffer
+                        const base64Data = file.data_url.split(",")[1];
+                        const binaryString = atob(base64Data);
+                        const bytes = new Uint8Array(binaryString.length);
+                        for (let i = 0; i < binaryString.length; i++) {
+                            bytes[i] = binaryString.charCodeAt(i);
+                        }
+                        const arrayBuffer = bytes.buffer;
+                        // Extract text from PDF
+                        const extractedText = await (0, pdfToText_1.pdfToText)(arrayBuffer);
+                        parsed_content = {
+                            version: 1,
+                            text: extractedText,
+                        };
+                        // Generate summary from extracted text
+                        if (extractedText.trim().length > 0) {
+                            summary = await (0, documentSummarizer_1.summarizeDocument)(extractedText);
+                        }
+                        logger.info(`[handleUserMessage] Extracted ${String(extractedText.length)}` +
+                            ` chars from PDF ${file.name}`);
+                    }
+                    catch (err) {
+                        logger.warn(`[handleUserMessage] Failed to extract PDF content: ` +
+                            String(err));
+                    }
+                }
+                await this.sessionFileManager.putFileContent(file.name, summary, file.data_url, parsed_content);
+            }
+            // Remove attachedFiles from the message so they don't get
+            // included in the LLM context
+            msg = { ...msg, attachedFiles: undefined };
+        }
         // Special case for the first message of the session
         if (userMessage.message_idx === conversation_1.MESSAGE_INDEX_START_VALUE) {
             // No need to wait for this to complete before broadcasting.
@@ -730,8 +876,8 @@ class OpenSession {
         this.isPersisted = true;
     }
     async onFirstMessage(userMsg) {
-        // Update title on the class before writing to the DB
-        this.sessionTitle = userMsg.message?.slice(0, 128) || "New Chat";
+        // Generate title using LLM with automatic fallback
+        this.sessionTitle = await this.titleGenerator.generateTitle(userMsg.message || "");
         // The session may already have been saved (e.g. if the workspace is
         // updated before any messages are sent).
         if (!this.isPersisted) {
@@ -865,7 +1011,7 @@ class OpenSession {
         return msgs;
     }
     async handleSetSystemPrompt(system_prompt) {
-        this.agent.setSystemPrompt(system_prompt);
+        this.contextManager.setAgentPrompt(system_prompt);
         await this.updateAgentProfile();
         return {
             type: "system_prompt_updated",
@@ -874,7 +1020,7 @@ class OpenSession {
         };
     }
     async handleSetModel(model) {
-        this.agent.setModel(model);
+        this.agent.llm.setModel(model);
         await this.updateAgentProfile();
         return { type: "model_updated", model, session_id: this.sessionUUID };
     }
@@ -953,8 +1099,11 @@ class OpenSession {
         }
         return tool;
     }
+    getAgentProfile() {
+        return new sdk_1.AgentProfile(this.agent.llm.getModel(), this.contextManager.getAgentPrompt(), this.skillManager.getMcpServerSettings());
+    }
     async updateAgentProfile() {
-        const profile = this.agent.getAgentProfile();
+        const profile = this.getAgentProfile();
         logger.debug(`[updateAgentProfile]: uuid: ${this.agentProfileUUID} profile: ` +
             JSON.stringify(profile));
         return this.db.updateAgentProfile(this.agentProfileUUID, profile);
@@ -1093,15 +1242,28 @@ async function loadSessionData(db, sessionId) {
         sessionParticipants: (0, database_1.createSessionParticipantMap)(sessionParticipants),
     };
 }
-async function createContextAndAgent(sessionUUID, systemPrompt, model, sessionMessages, workspace, sessionCheckpoint, ownerData, ownerApiKey, llmUrl, xmcpUrl, fileManager, sender, platform, approvalManager) {
-    const contextManager = new chatContextManager_1.ChatContextManager(systemPrompt, sessionMessages, sessionUUID, ownerData.uuid, sessionCheckpoint, llmUrl, model, ownerApiKey, undefined, // TODO
-    fileManager);
+async function createLLM(model, platform) {
+    let llm = await (0, agentUtils_1.createSpecializedLLM)(model, platform);
+    if (!llm) {
+        llm = new openAIRouterLLM_1.OpenAIRouterLLM(model);
+    }
+    (0, assert_1.strict)(llm);
+    return llm;
+}
+async function createContextAndAgent(sessionUUID, systemPrompt, model, sessionMessages, workspace, sessionCheckpoint, ownerData, ownerApiKey, xmcpUrl, fileManager, platform, checkpointWriter, messageSender) {
+    // Create SkillManager
+    const xmcpConfig = sdk_1.Configuration.new(ownerApiKey, xmcpUrl, false);
+    const skillManager = await sudoMcpServerManager_1.SkillManager.initialize((url, authResultP, displayName) => {
+        platform.openUrl(url, authResultP, displayName);
+    }, xmcpConfig.backend_url, xmcpConfig.api_key, undefined /* authorizedUrl */);
+    // Fn to create the llm.  One invocation for the compression context, one
+    // for the Agent.
+    const llm = await createLLM(model, platform);
+    const agent = new agent_1.AgentEx(skillManager, llm);
+    await (0, tools_1.addDefaultChatTools)(agent, ownerData.timezone, platform, fileManager, messageSender);
+    const contextManager = new chatContextManager_1.ChatContextManager(systemPrompt, sessionMessages, sessionUUID, ownerData.uuid, sessionCheckpoint, checkpointWriter, fileManager, await createLLM(model, platform));
     if (workspace) {
         contextManager.setWorkspace((0, agent_1.createUserMessage)(workspace.message, workspace.imageB64));
     }
-    const eventHandler = new ChatSessionAgentEventHandler(sessionUUID, sender, approvalManager, contextManager);
-    const xmcpConfig = sdk_1.Configuration.new(ownerApiKey, xmcpUrl, false);
-    const [agent, skillManager] = await (0, agentUtils_1.createAgentWithoutSkills)(llmUrl, model, eventHandler, platform, contextManager, ownerApiKey, xmcpConfig, undefined, true);
-    await (0, tools_1.addDefaultChatTools)(agent, ownerData.timezone, fileManager, llmUrl, ownerApiKey);
     return { agent, skillManager, contextManager };
 }