@xalia/agent 0.6.2 → 0.6.3

package/dist/agent/src/agent/agent.js

@@ -85,12 +85,15 @@ class Agent {
                 // `toolCallResults`.
                 const result = await this.doToolCall(toolCall);
                 toolCallResults.push([context.length, result]);
-                context.push({
+                const toolResult = {
                     role: "tool",
                     tool_call_id: toolCall.id,
                     content: result.response,
-                    metadata: result.metadata,
-                });
+                };
+                if (result.metadata) {
+                    toolResult.metadata = result.metadata;
+                }
+                context.push(toolResult);
                 // If the tool call requested that its args be redacted, this can be
                 // done now - before the next LLM invocation.
                 if (result.overwriteArgs) {
@@ -221,14 +224,14 @@ class Agent {
                     result = { response: "User denied tool request." };
                 }
                 else {
-                    const args = JSON.parse(toolCall.function.arguments);
+                    const args = JSON.parse(toolCall.function.arguments || "{}");
                     result = await agentTool.handler(this, args);
                 }
             }
             else {
                 // McpServer tool call (agentTool === undefined).  Sanity check the
                 // tool call data, get approval, and then invoke.
-                const args = JSON.parse(toolCall.function.arguments);
+                const args = JSON.parse(toolCall.function.arguments || "{}");
                 const tc = this.mcpServerManager.verifyToolCall(toolName, args);
                 if (!(await this.eventHandler.onToolCall(toolCall, false))) {
                     result = { response: "User denied tool request." };

package/dist/agent/src/agent/agentUtils.js

@@ -17,16 +17,14 @@ const repeatLLM_1 = require("./repeatLLM");
 const context_1 = require("./context");
 const imageGenLLM_1 = require("./imageGenLLM");
 const logger = (0, sdk_1.getLogger)();
-async function createAgentWithoutSkills(llmUrl, agentProfile, defaultModel, eventHandler, platform, contextManager, llmApiKey, sudomcpConfig, authorizedUrl, stream = false) {
+async function createAgentWithoutSkills(llmUrl, model, eventHandler, platform, contextManager, llmApiKey, sudomcpConfig, authorizedUrl, stream = false) {
     // Init SudoMcpServerManager
     logger.debug("[createAgentWithSkills] creating SudoMcpServerManager.");
     const sudoMcpServerManager = await sudoMcpServerManager_1.SkillManager.initialize((url, authResultP, displayName) => {
         platform.openUrl(url, authResultP, displayName);
     }, sudomcpConfig.backend_url, sudomcpConfig.api_key, authorizedUrl);
-    logger.debug("[createAgentWithoutSkills] restore mcp settings:" +
-        JSON.stringify(agentProfile.mcp_settings));
     // Create agent using the event handler
-    const agent = await createAgentFromSkillManager(llmUrl, agentProfile, defaultModel, eventHandler, platform, contextManager, llmApiKey, sudoMcpServerManager, stream);
+    const agent = await createAgentFromSkillManager(llmUrl, model, eventHandler, platform, contextManager, llmApiKey, sudoMcpServerManager, stream);
     return [agent, sudoMcpServerManager];
 }
 /**
@@ -34,17 +32,16 @@ async function createAgentWithoutSkills(llmUrl, agentProfile, defaultModel, even
  * IAgentEventHandler interface. This is the preferred way to create
  * agents.
  */
-async function createAgentWithSkills(llmUrl, agentProfile, defaultModel, eventHandler, platform, contextManager, llmApiKey, sudomcpConfig, authorizedUrl, stream = false) {
-    const [agent, sudoMcpServerManager] = await createAgentWithoutSkills(llmUrl, agentProfile, defaultModel, eventHandler, platform, contextManager, llmApiKey, sudomcpConfig, authorizedUrl, stream);
-    logger.debug("[createAgentWithSkills] restoring skills");
-    await sudoMcpServerManager.restoreMcpSettings(agentProfile.mcp_settings);
+async function createAgentWithSkills(llmUrl, model, eventHandler, platform, contextManager, llmApiKey, sudomcpConfig, mcpSettings, authorizedUrl, stream = false) {
+    const [agent, sudoMcpServerManager] = await createAgentWithoutSkills(llmUrl, model, eventHandler, platform, contextManager, llmApiKey, sudomcpConfig, authorizedUrl, stream);
+    logger.debug(`[createAgentWithSkills] skilles: ${JSON.stringify(mcpSettings)}`);
+    await sudoMcpServerManager.restoreMcpSettings(mcpSettings);
     return [agent, sudoMcpServerManager];
 }
-async function createAgentFromSkillManager(llmUrl, agentProfile, defaultModel, eventHandler, platform, contextManager, llmApiKey, skillManager, stream = false) {
+async function createAgentFromSkillManager(llmUrl, model, eventHandler, platform, contextManager, llmApiKey, skillManager, stream = false) {
     // Create agent
     logger.debug("[createAgentFromSkillManager] creating agent ...");
-    const llm = await createLLM(llmUrl, llmApiKey, agentProfile.model || defaultModel, stream, platform);
-    contextManager.setAgentPrompt(agentProfile.system_prompt);
+    const llm = await createLLM(llmUrl, llmApiKey, model, stream, platform);
     const agent = agent_1.Agent.initializeWithLLM(eventHandler, llm, contextManager, skillManager);
     logger.debug("[createAgentFromSkillManager] done");
     return agent;
@@ -101,7 +98,7 @@ async function createNonInteractiveAgent(url, agentProfile, defaultModel, conver
         onToolCallResult: () => { },
     };
     const contextManager = new context_1.ContextManager(agentProfile.system_prompt, conversation || []);
-    const [agent, _] = await createAgentWithSkills(url, agentProfile, defaultModel, eventHandler, platform, contextManager, openaiApiKey, sudomcpConfig, undefined);
+    const [agent, _] = await createAgentWithSkills(url, agentProfile.model || defaultModel, eventHandler, platform, contextManager, openaiApiKey, sudomcpConfig, agentProfile.mcp_settings, undefined);
     return agent;
 }
 /**

package/dist/agent/src/chat/client/chatClient.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatClient = void 0;
 const uuid_1 = require("uuid");
+const assert_1 = require("assert");
 const sdk_1 = require("@xalia/xmcp/sdk");
 const connection_1 = require("./connection");
 const sessionClient_1 = require("./sessionClient");
@@ -9,41 +10,31 @@ const database_1 = require("../data/database");
 const messages_1 = require("../protocol/messages");
 const constants_1 = require("./constants");
 const agentSessionMap_1 = require("../utils/agentSessionMap");
+const responseAwaiter_1 = require("../utils/responseAwaiter");
 const logger = (0, sdk_1.getLogger)();
+function idExtractor(msg) {
+    return msg.client_message_id;
+}
 class ChatClient {
-    constructor(connection, eventHandler, 
-    // agent_uuid -> agent session data
-    userAgentSessionMap = new Map(), 
-    // team_uuid -> team info
-    teams = new Map(), 
-    // Whether this client is in guest mode
-    isGuestMode = false, closed = false, currentSessionId = undefined, 
-    // note: currentTeamId will not be reset when swtiching to a user session.
-    currentTeamId = undefined, 
-    // session_uuid -> session client
-    activeSessions = new Map(), 
-    // session_uuid -> true if there is a new message.
-    newMessage = new Map(), 
-    // Track pending session join request, this should be a singleton
-    sessionJoinOrCreateRes = undefined) {
+    constructor(connection, eventHandler, userAgentSessionMap, teams, isGuestMode) {
         this.connection = connection;
         this.eventHandler = eventHandler;
         this.userAgentSessionMap = userAgentSessionMap;
         this.teams = teams;
         this.isGuestMode = isGuestMode;
-        this.closed = closed;
-        this.currentSessionId = currentSessionId;
-        this.currentTeamId = currentTeamId;
-        this.activeSessions = activeSessions;
-        this.newMessage = newMessage;
-        this.sessionJoinOrCreateRes = sessionJoinOrCreateRes;
+        this.closed = false;
+        this.currentSessionId = undefined;
+        this.currentTeamId = undefined;
+        this.activeSessions = new Map();
+        this.newMessage = new Map();
+        this.sessionJoinAwaiter = responseAwaiter_1.ResponseAwaiter.initWithImmediate("control_error", idExtractor, this.onJoinCreateResponse.bind(this), Math.max(constants_1.SESSION_JOIN_TIMEOUT));
     }
     /**
      * Connect to server and create ChatClient instance
      */
     static async init(url, token, eventHandler) {
         // Determine if this is a guest token (format: guest_<hash>_<session-id>)
-        const isGuestMode = token.startsWith('guest_');
+        const isGuestMode = token.startsWith("guest_");
         const connection = new connection_1.Connection({
             url,
             token,
@@ -217,70 +208,26 @@ class ChatClient {
         this.teams.clear();
         this.currentSessionId = undefined;
         this.currentTeamId = undefined;
-        this.sessionJoinOrCreateRes = undefined;
     }
     async createNewSession(newTitle, agentProfileId, teamId) {
         if (this.closed) {
             throw new Error("ChatClient is closed");
         }
-        if (this.sessionJoinOrCreateRes) {
-            logger.error(`[ChatClient] creating new session with ` +
-                `profile id ${JSON.stringify(agentProfileId)}`);
-            throw new Error("Session join/create is already in progress");
-        }
-        return new Promise((resolve, reject) => {
-            const clientMessageId = (0, uuid_1.v4)();
-            // Set up timeout for the request
-            const timeoutId = setTimeout(() => {
-                this.sessionJoinOrCreateRes = undefined;
-                reject(new Error(`Session join timeout for creating new session`));
-            }, constants_1.SESSION_CREATE_TIMEOUT);
-            // Track this pending request
-            this.sessionJoinOrCreateRes = {
-                resolve: (sessionClient, sessionInfo) => {
-                    const sessionId = this.sessionJoinOrCreateRes?.sessionId;
-                    if (!sessionId) {
-                        throw new Error("Session id is not set in resolving.");
-                    }
-                    if (sessionId !== sessionInfo.session_id) {
-                        throw new Error("SessionInfo id mismatch");
-                    }
-                    clearTimeout(timeoutId);
-                    this.activeSessions.set(sessionId, sessionClient);
-                    this.currentSessionId = sessionId;
-                    if (sessionInfo.team_uuid) {
-                        this.currentTeamId = sessionInfo.team_uuid;
-                    }
-                    this.sessionJoinOrCreateRes = undefined;
-                    this.addSessionToAgentSessionMap(sessionInfo);
-                    resolve(sessionClient);
-                },
-                reject: (error) => {
-                    clearTimeout(timeoutId);
-                    this.sessionJoinOrCreateRes = undefined;
-                    reject(error);
-                },
-                sessionId: "",
-                clientMessageId,
-            };
-            // Send session_create message
-            try {
-                this.connection.send({
-                    type: "control_session_create",
-                    client_message_id: clientMessageId,
-                    title: newTitle,
-                    agent_profile_id: agentProfileId,
-                    team_id: teamId,
-                });
-                logger.info(`[ChatClient] Sent session_create for session ${newTitle}` +
-                    ` client message id: ${clientMessageId}`);
-            }
-            catch (error) {
-                this.sessionJoinOrCreateRes = undefined;
-                clearTimeout(timeoutId);
-                reject(error instanceof Error ? error : new Error(String(error)));
-            }
-        });
+        const clientMessageId = (0, uuid_1.v4)();
+        const createdSessionP = this.sessionJoinAwaiter.waitForResponse(clientMessageId);
+        const createMsg = {
+            type: "control_session_create",
+            client_message_id: clientMessageId,
+            title: newTitle,
+            agent_profile_id: agentProfileId,
+            team_id: teamId,
+        };
+        this.connection.send(createMsg);
+        logger.info(`[ChatClient] Sent ${JSON.stringify(createMsg)}`);
+        const createdSession = await createdSessionP;
+        const sessionId = createdSession.client.getSessionUUID();
+        logger.info(`[ChatClient] joined session ${sessionId}`);
+        return createdSession.client;
     }
     /**
      * Connect to an existing session by sending session_join message
@@ -290,58 +237,22 @@ class ChatClient {
         if (this.closed) {
             throw new Error("ChatClient is closed");
         }
-        if (this.sessionJoinOrCreateRes) {
-            logger.error(`[ChatClient] connecting to session ${sessionId}`);
-            throw new Error("Session join/create is already in progress");
-        }
-        // TODO: we can directly return a session client if we cache conversation.
-        // For now, we go through the join process.
-        return new Promise((resolve, reject) => {
-            const clientMessageId = (0, uuid_1.v4)();
-            // Set up timeout for the request
-            const timeoutId = setTimeout(() => {
-                this.sessionJoinOrCreateRes = undefined;
-                reject(new Error(`Session join timeout for session ${sessionId}`));
-            }, constants_1.SESSION_JOIN_TIMEOUT);
-            // Track this pending request
-            this.sessionJoinOrCreateRes = {
-                resolve: (sessionClient, sessionInfo) => {
-                    clearTimeout(timeoutId);
-                    this.activeSessions.set(sessionId, sessionClient);
-                    this.currentSessionId = sessionId;
-                    if (sessionInfo.team_uuid) {
-                        this.currentTeamId = sessionInfo.team_uuid;
-                    }
-                    this.sessionJoinOrCreateRes = undefined;
-                    this.updateSessionInfo(sessionInfo);
-                    logger.info(`[ChatClient] joined session ${sessionId}`);
-                    resolve(sessionClient);
-                },
-                reject: (error) => {
-                    clearTimeout(timeoutId);
-                    this.sessionJoinOrCreateRes = undefined;
-                    logger.error(`[ChatClient] failed to join session` +
-                        ` ${sessionId}: ${error.message}`);
-                    reject(error);
-                },
-                sessionId,
-                clientMessageId,
-            };
-            // Send session_join message
-            try {
-                this.connection.send({
-                    type: "control_session_join",
-                    client_message_id: clientMessageId,
-                    target_session_id: sessionId,
-                });
-                logger.debug(`[ChatClient] Sent session_join for session ${sessionId}`);
-            }
-            catch (error) {
-                this.sessionJoinOrCreateRes = undefined;
-                clearTimeout(timeoutId);
-                reject(error instanceof Error ? error : new Error(String(error)));
-            }
+        const clientMessageId = (0, uuid_1.v4)();
+        const createdSessionP = this.sessionJoinAwaiter.waitForResponse(clientMessageId);
+        this.connection.send({
+            type: "control_session_join",
+            client_message_id: clientMessageId,
+            target_session_id: sessionId,
         });
+        logger.debug(`[ChatClient] Sent session_join for session ${sessionId}`);
+        // Await the response
+        const createdSession = await createdSessionP;
+        const newSessionId = createdSession.client.getSessionUUID();
+        if (newSessionId !== sessionId) {
+            throw new Error(`unexpected session id ${newSessionId}`);
+        }
+        logger.info(`[ChatClient] joined session ${sessionId}`);
+        return createdSession.client;
     }
     /**
      * Fetch the session list from the server
@@ -649,97 +560,28 @@ class ChatClient {
      * Handle session_info message which can be for:
      * 1. A pending session join/create request
      * 2. An update to an existing active session
+     * 3. A new session notification
      * We update the session list here as well.
      */
     handleSessionInfoMessage(msg) {
-        const sessionId = msg.session_id;
-        // There is a pending request, check if this is the response
-        if (this.sessionJoinOrCreateRes &&
-            msg.client_message_id === this.sessionJoinOrCreateRes.clientMessageId) {
-            const { resolve, reject } = this.sessionJoinOrCreateRes;
-            try {
-                logger.info(`[ChatClient] Creating SessionClient for session ${sessionId}`);
-                logger.info(`[ChatClient] msg: ${JSON.stringify(msg)}`);
-                const sessionClient = new sessionClient_1.SessionClient(sessionId, msg.saved_agent_profile, this.connection, msg.mcp_server_briefs, (0, database_1.createSessionParticipantMap)(msg.participants), msg.agent_paused);
-                // we need to pass the session id if this is a new session
-                if (this.sessionJoinOrCreateRes.sessionId === "") {
-                    this.sessionJoinOrCreateRes.sessionId = sessionId;
-                }
-                else if (this.sessionJoinOrCreateRes.sessionId !== sessionId) {
-                    throw new Error(`[ChatClient] session id mismatch: ` +
-                        `${this.sessionJoinOrCreateRes.sessionId} !== ${sessionId}`);
-                }
-                resolve(sessionClient, msg);
-            }
-            catch (error) {
-                const errorMsg = error instanceof Error ? error : new Error(String(error));
-                logger.error(`[ChatClient] Failed to create SessionClient: ${errorMsg.message}`);
-                reject(errorMsg);
-            }
-        }
-        else {
-            this.updateSessionInfo(msg);
+        // We intercept messages for th Awaiter here so that we can create and
+        // register the client immediately, before other messages for this session
+        // are handled.  Relying on Awaiter alone (currently) schedules the resolv
+        // to be called later (potentially AFTER further messages for the session
+        // have been received).
+        if (this.sessionJoinAwaiter.onMessage(msg)) {
+            return;
         }
+        logger.debug(`[ChatClient.handleSessionInfoMessage] not handled by awaiter - updating`);
+        this.upsertSessionToAgentSessionMap(msg);
     }
     handleControlError(msg) {
-        // reject the pending session join/create request if message id matches
-        if (this.sessionJoinOrCreateRes &&
-            msg.client_message_id === this.sessionJoinOrCreateRes.clientMessageId) {
-            this.sessionJoinOrCreateRes.reject(new Error(msg.message));
-        }
-        this.eventHandler.onError(`Server error: ${msg.message}`);
-    }
-    /**
-     * Update the session list. This is called when a session is updated.
-     * An error is thrown if the session id is not found.
-     * TODO: we might want to resync session map, for now, throw error to
-     * expose problems in the code.
-     */
-    updateAgentSessionMap(sessionInfo) {
-        const sessionId = sessionInfo.session_id;
-        // Skip agent session map updates for guest sessions since they don't
-        // need session organization
-        if (this.isGuestMode) {
-            logger.info(`[ChatClient] Skipping agent session map update for ` +
-                `guest session ${sessionId}`);
+        if (this.sessionJoinAwaiter.onMessage(msg)) {
             return;
         }
-        if (sessionInfo.team_uuid) {
-            const teamInfo = this.teams.get(sessionInfo.team_uuid);
-            if (!teamInfo) {
-                throw new Error(`Team ${sessionInfo.team_uuid} not found in team list`);
-            }
-            const agentSessionMap = teamInfo.agentSessionMap;
-            if (!doUpdateAgentSessionMap(agentSessionMap, sessionInfo)) {
-                throw new Error(`[updateAgentSessionMap] team session ${sessionId}` +
-                    ` not found in agent session map`);
-            }
-        }
-        else {
-            const agentSessionMap = this.userAgentSessionMap;
-            if (!doUpdateAgentSessionMap(agentSessionMap, sessionInfo)) {
-                throw new Error(`[updateAgentSessionMap] user session ${sessionId}` +
-                    ` not found in agent session map`);
-            }
-        }
-    }
-    /**
-     * Update the SessionDescriptor info for an existing session, given a full
-     * ServerSessionInfo. This also passes the session info to the session
-     * client. An error is thrown if the session client is not found.
-     */
-    updateSessionInfo(msg) {
-        const sessionId = msg.session_id;
-        const sessionClient = this.activeSessions.get(sessionId);
-        this.updateAgentSessionMap(msg);
-        if (sessionClient) {
-            sessionClient.updateSessionInfo(msg);
-        }
-        else {
-            throw new Error(`Session client not found for session ${sessionId}`);
-        }
+        this.eventHandler.onError(`Server error: ${msg.message}`);
     }
-    addSessionToAgentSessionMap(msg) {
+    upsertSessionToAgentSessionMap(msg) {
         // Skip agent session map updates for guest sessions since they don't
         // need session organization
         if (this.isGuestMode) {
@@ -761,9 +603,40 @@ class ChatClient {
             throw new Error(`[addSessionToAgentSessionMap] Agent ${agentUuid}` +
                 ` not found in agent session map`);
         }
-        agentSession.sessions.push(sessionInfoToSessionDescriptor(msg));
+        // Check if session already exists
+        const existingSessionIndex = agentSession.sessions.findIndex((session) => session.session_uuid === msg.session_id);
+        if (existingSessionIndex !== -1) {
+            // Update existing session
+            agentSession.sessions[existingSessionIndex] =
+                sessionInfoToSessionDescriptor(msg);
+            logger.info(`[ChatClient] Updated existing session ${msg.session_id} in ` +
+                `agent session map`);
+        }
+        else {
+            // Add new session
+            agentSession.sessions.push(sessionInfoToSessionDescriptor(msg));
+            logger.info(`[ChatClient] Added new session ${msg.session_id} to agent session map`);
+        }
         agentSession.updated_at = new Date(msg.updated_at).getTime();
     }
+    // This is the immediate callback of the ResponseAwaiter for session
+    // joining.  It must create and register the client.
+    onJoinCreateResponse(msg) {
+        // Errors should not get through here.
+        (0, assert_1.strict)(msg.type === "session_info");
+        const sessionId = msg.session_id;
+        const client = new sessionClient_1.SessionClient(sessionId, msg.saved_agent_profile, this.connection, msg.mcp_server_briefs, (0, database_1.createSessionParticipantMap)(msg.participants), msg.agent_paused);
+        this.activeSessions.set(sessionId, client);
+        this.currentSessionId = sessionId;
+        if (msg.team_uuid) {
+            this.currentTeamId = msg.team_uuid;
+        }
+        this.upsertSessionToAgentSessionMap(msg);
+        return {
+            client,
+            sessionInfo: msg,
+        };
+    }
 }
 exports.ChatClient = ChatClient;
 function sessionInfoToSessionDescriptor(msg) {
@@ -777,28 +650,3 @@ function sessionInfoToSessionDescriptor(msg) {
         agent_paused: msg.agent_paused,
     };
 }
-/**
- * Update the agent session map
- * @param agentSessionMap - the agent session map
- * @param sessionInfo - the session info
- * @returns true if the session is updated, false otherwise
- */
-function doUpdateAgentSessionMap(agentSessionMap, sessionInfo) {
-    const sessionId = sessionInfo.session_id;
-    const agentUuid = sessionInfo.saved_agent_profile.uuid;
-    const agent = agentSessionMap.get(agentUuid);
-    if (!agent) {
-        return false;
-    }
-    let updated = false;
-    agent.sessions.map((session) => {
-        if (session.session_uuid === sessionId) {
-            updated = true;
-            return sessionInfoToSessionDescriptor(sessionInfo);
-        }
-        else {
-            return session;
-        }
-    });
-    return updated;
-}

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

@@ -1,5 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SESSION_CREATE_TIMEOUT = exports.SESSION_JOIN_TIMEOUT = void 0;
+exports.SESSION_JOIN_TIMEOUT = void 0;
 exports.SESSION_JOIN_TIMEOUT = 6000; // 6 seconds
-exports.SESSION_CREATE_TIMEOUT = 6000; // 6 seconds

package/dist/agent/src/chat/client/sessionClient.js

@@ -6,9 +6,8 @@ const uuid_1 = require("uuid");
 const sdk_1 = require("@xalia/xmcp/sdk");
 const mcpServerManager_1 = require("../../agent/mcpServerManager");
 const messages_1 = require("../protocol/messages");
-const database_1 = require("../data/database");
 const sessionFiles_1 = require("./sessionFiles");
-const responseHandler_1 = require("./responseHandler");
+const responseAwaiter_1 = require("../utils/responseAwaiter");
 const logger = (0, sdk_1.getLogger)();
 class RemoteSudoMcpServerManager {
     constructor(sender, briefs) {
@@ -153,7 +152,7 @@ class SessionClient {
         this.sender = sender;
         this.smsm = new RemoteSudoMcpServerManager(this, serverBriefs);
         this.sessionFiles = new sessionFiles_1.SessionFiles(sessionUUID, fileList, sender);
-        this.responseHandler = new responseHandler_1.ResponseHandler("session_error");
+        this.responseHandler = responseAwaiter_1.ResponseAwaiter.init("session_error", (msg) => msg.client_message_id);
         this.participants = participants;
         this.systemPrompt = "";
         this.model = "";
@@ -267,11 +266,6 @@ class SessionClient {
         };
         this.sender.send(enrichedMessage);
     }
-    updateSessionInfo(sessionInfo) {
-        // TODO: Determine the correct approach. Cache the workspace?
-        const infoStr = JSON.stringify(sessionInfo.workspace);
-        logger.debug(`[SessionClient] ignoring session info: ${infoStr}`);
-    }
     setWorkspace(message, imageB64) {
         const msg = {
             type: "set_workspace",
@@ -303,7 +297,7 @@ class SessionClient {
             session_id: this.sessionUUID,
         };
         this.sender.send(msg);
-        const response = await this.responseHandler.waitForResponse(msg);
+        const response = await this.responseHandler.waitForResponse(msg.client_message_id);
         if (response.type === "session_shared") {
             return response.access_token;
         }
@@ -337,10 +331,7 @@ class SessionClient {
                 this.model = message.model;
                 break;
             case "session_info":
-                // Update participants if we receive session_info again
-                if ("participants" in message) {
-                    this.participants = (0, database_1.createSessionParticipantMap)(message.participants);
-                }
+                // This is handled in the layer above, in the chatClient
                 break;
             case "user_added":
                 this.participants.set(message.user_uuid, {

package/dist/agent/src/chat/client/sessionFiles.js

@@ -4,7 +4,7 @@ exports.SessionFiles = void 0;
 const uuid_1 = require("uuid");
 const assert_1 = require("assert");
 const sdk_1 = require("@xalia/xmcp/sdk");
-const responseHandler_1 = require("./responseHandler");
+const responseAwaiter_1 = require("../utils/responseAwaiter");
 const logger = (0, sdk_1.getLogger)();
 /// Object for the UI to use to interact with the FileManager.  If the UI
 /// receives ServerSessionFileChanged or ServerSessionFileDeleted then it
@@ -14,7 +14,7 @@ class SessionFiles {
     constructor(sessionUUID, initialFileList, sender) {
         this.sessionUUID = sessionUUID;
         this.descriptors = new Map(initialFileList.map((d) => [d.name, d]));
-        this.responseHandler = new responseHandler_1.ResponseHandler(undefined);
+        this.responseHandler = responseAwaiter_1.ResponseAwaiter.init(undefined, (msg) => msg.client_message_id);
         this.sender = sender;
     }
     listFiles() {
@@ -31,7 +31,7 @@ class SessionFiles {
             client_message_id: (0, uuid_1.v4)(),
         };
         this.sender.send(msg);
-        const response = await this.responseHandler.waitForResponse(msg);
+        const response = await this.responseHandler.waitForResponse(msg.client_message_id);
         if (response.name !== name) {
             throw new Error(`invalid name for file ${name}: ${JSON.stringify(response)}`);
         }

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

@@ -72,7 +72,6 @@ function isServerSessionScopedMessage(message) {
         case "agent_reasoning_chunk":
         case "user_joined":
         case "user_left":
-        case "session_update":
         case "tool_auto_approval_set":
         case "tool_call":
         case "tool_call_approval_result":

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

@@ -99,7 +99,7 @@ class ChatContextManager {
     getConversationMessages() {
         return this.conversationMessages.concat(this.pendingUserMessages);
     }
-    processUserMessage(msg, from) {
+    processUserMessage(msg, from_uuid, from_nickname) {
         // TODO: maintain a queue internally instead of relying on the caller to
         // pass in our generated messages back into `startAgentResponse`.
         // Filter out null messages immediately.
@@ -112,7 +112,8 @@ class ChatContextManager {
             session_id: this.sessionUUID,
             message_idx,
             message: msg.message,
-            user_uuid: from,
+            user_uuid: from_uuid,
+            user_nickname: from_nickname,
         };
         if (msg.imageB64) {
             userMessage.imageB64 = msg.imageB64;
@@ -149,7 +150,7 @@ class ChatContextManager {
         // 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);
+            const userMsg = (0, agent_1.createUserMessage)(msg.message, msg.imageB64, msg.user_nickname);
             if (userMsg) {
                 llmUserMessages.push(userMsg);
             }
@@ -200,7 +201,7 @@ class ChatContextManager {
             }
             if (JSON.stringify(sMsg.content) !== JSON.stringify(lMsg)) {
                 messageListError(`newSessionMessages[${String(i)}].content !== ` +
-                    `newLLMMessages[${String(i)}].content`);
+                    `newLLMMessages[${String(i)}]`);
             }
             if (sMsg.message_idx !== pMsg.message_idx) {
                 messageListError(`newSessionMessages[${String(i)}].message_idx !== ` +
@@ -244,11 +245,6 @@ class ChatContextManager {
         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");

package/dist/agent/src/chat/server/connectionManager.test.js

@@ -61,6 +61,7 @@ vitest_1.vi.mock("ws");
                 d: {
                     type: "user_msg",
                     user_uuid: "user_1",
+                    user_nickname: "User 1",
                     session_id: "session_1",
                     message: "message text",
                     message_idx: 12,