@xalia/agent 0.6.1 → 0.6.3

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbSessionMessages = void 0;
+const database_1 = require("./database");
+class DbSessionMessages extends database_1.DbClientBase {
+    async clearConversation(session_uuid) {
+        const { error } = await this.client
+            .from("session_messages")
+            .delete()
+            .eq("session_uuid", session_uuid);
+        if (error) {
+            throw error;
+        }
+    }
+    async getConversation(session_uuid, numEntries, beforeIndex) {
+        // Query all message for the given session, ordered high-to-low by
+        // message_idx, limited to `numEntries`.  If `beforeIndex` is given, it
+        // means we get messages with `message_idx < beforeIndex`
+        let query = this.client
+            .from("session_messages")
+            .select("message_idx,sender_uuid,is_for_llm,content")
+            .eq("session_uuid", session_uuid);
+        if (beforeIndex) {
+            query = query.lt("message_idx", beforeIndex);
+        }
+        query = query.order("message_idx", { ascending: false }).limit(numEntries);
+        const { data, error } = await query;
+        if (error) {
+            throw error;
+        }
+        // To get the newest N messages, we've orded by index largest to smallest
+        // (newest first), but caller wants the message first to last, hence
+        // reverse the array.
+        return data
+            .map(({ sender_uuid, ...rest }) => {
+            return typeof sender_uuid === "string"
+                ? {
+                    sender_uuid,
+                    ...rest,
+                }
+                : { ...rest };
+        })
+            .reverse();
+    }
+    async append(session_uuid, messages) {
+        const payload = messages.map((m) => {
+            return { ...m, session_uuid };
+        });
+        const { error } = await this.client
+            .from("session_messages")
+            .insert(payload);
+        if (error) {
+            throw error;
+        }
+    }
+}
+exports.DbSessionMessages = DbSessionMessages;

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXTENSION_TO_IMAGE_MIME_TYPE = exports.IMAGE_MIME_TYPES = void 0;
+exports.isImageMimeType = isImageMimeType;
+exports.getMimeTypeFromDataUrl = getMimeTypeFromDataUrl;
+exports.createDataUrlFromBuffer = createDataUrlFromBuffer;
+exports.createDataUrlFromText = createDataUrlFromText;
+const assert_1 = require("assert");
+exports.IMAGE_MIME_TYPES = [
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+];
+function isImageMimeType(mime_type) {
+    return (typeof mime_type === "string" &&
+        exports.IMAGE_MIME_TYPES.includes(mime_type));
+}
+exports.EXTENSION_TO_IMAGE_MIME_TYPE = {
+    jpg: "image/jpeg",
+    jpeg: "image/jpeg",
+    png: "image/png",
+    gif: "image/gif",
+    webp: "image/webp",
+};
+function getMimeTypeFromDataUrl(data_url) {
+    // data:image/png;base64,AAAAA...
+    (0, assert_1.strict)(data_url.startsWith("data:"));
+    const endOfMimeType = data_url.indexOf(",");
+    (0, assert_1.strict)(endOfMimeType > 5);
+    let mimeType = data_url.slice(5, endOfMimeType);
+    const paramIdx = mimeType.indexOf(";");
+    if (paramIdx >= 0) {
+        mimeType = mimeType.slice(0, paramIdx);
+    }
+    return mimeType;
+}
+function createDataUrlFromBuffer(data, mime_type) {
+    const imgB64 = data.toString("base64");
+    return `data:${mime_type};base64,${imgB64}`;
+}
+function createDataUrlFromText(data, mime_type) {
+    return `data:${mime_type},${data}`;
+}

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isClientControlMessage = isClientControlMessage;
 exports.isServerControlMessage = isServerControlMessage;
+exports.isServerSessionFileMessage = isServerSessionFileMessage;
 exports.isServerSessionScopedMessage = isServerSessionScopedMessage;
 exports.decodeAssistantMessageParam = decodeAssistantMessageParam;
 function isClientControlMessage(message) {
@@ -35,6 +36,7 @@ function isServerControlMessage(message) {
         case "control_session_left":
         case "control_session_deleted":
         case "control_team_created":
+        case "control_team_members_updated":
         case "control_error":
             return true;
         default: {
@@ -43,6 +45,19 @@ function isServerControlMessage(message) {
         }
     }
 }
+function isServerSessionFileMessage(message) {
+    const msg = message;
+    switch (msg.type) {
+        case "session_file_changed":
+        case "session_file_deleted":
+        case "session_file_content":
+            return true;
+        default: {
+            const _ = msg;
+            return false;
+        }
+    }
+}
 /**
  * Type guard to check if a ServerToClient message is a session-scoped message
  */
@@ -54,9 +69,9 @@ function isServerSessionScopedMessage(message) {
         case "user_msg":
         case "agent_msg":
         case "agent_msg_chunk":
+        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":
@@ -64,17 +79,22 @@ function isServerSessionScopedMessage(message) {
         case "authentication_started":
         case "authentication_finished":
         case "user_typing":
+        case "session_file_changed":
+        case "session_file_deleted":
+        case "session_file_content":
         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 "agent_paused":
         case "user_added":
         case "user_removed":
         case "authenticate":
         case "approve_tool_call":
         case "render_html":
+        case "session_shared":
             return true;
         default: {
             const _ = msg;

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

@@ -31,7 +31,7 @@ class ChatContextManager {
         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.conversationMessages = (0, conversation_1.sessionMessagesToConversationMessages)(sessionMessages, defaultUserName, sessionUUID);
         this.pendingUserMessages = [];
         this.llmContext = new compressingContextManager_1.CompressingContextManager(systemPrompt, llmMessages, compressionAgentUrl, compressionAgentModel, compressionAgentApiKey);
         this.nextMessageIdx = nextMessageIdx;
@@ -41,7 +41,7 @@ class ChatContextManager {
         this.pendingCompression = false;
         this.checkpointWriter = checkpointWriter;
         this.fileManager = fileManager;
-        fileManager.setEventHandler(this);
+        fileManager.addEventHandler(this);
         this.fileManagerDescriptionsDirty = true;
     }
     // IContextManager.addMessages
@@ -83,7 +83,10 @@ class ChatContextManager {
         this.fileManagerDescriptionsDirty = true;
     }
     // ISessionFileManagerEventHandler.onFileChange
-    onFileChange(_entry) {
+    onFileChanged(_entry) {
+        this.fileManagerDescriptionsDirty = true;
+    }
+    onFileDeleted(_name) {
         this.fileManagerDescriptionsDirty = true;
     }
     setWorkspace(userMessage) {
@@ -96,16 +99,21 @@ 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.
+        if (!msg.imageB64 && !msg.message) {
+            return undefined;
+        }
         const message_idx = this.getNextMessageIdx();
         const userMessage = {
             type: "user_msg",
             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;
@@ -142,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);
             }
@@ -159,11 +167,11 @@ class ChatContextManager {
         };
     }
     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");
+        (0, assert_1.strict)(typeof this.startingLLMContextLength !== "undefined", "agent response not started (startingLLMContextLength)");
+        (0, assert_1.strict)(typeof this.pendingMessages !== "undefined", "agent response not started (pendingMessages)");
+        (0, assert_1.strict)(typeof this.curAgentMsgIdx !== "undefined", "agent response not started (curAgentMsgIdx)");
         const numPending = this.pendingMessages.length;
-        (0, assert_1.strict)(numPending > 1); // 1 user + 1 agent message
+        (0, assert_1.strict)(numPending > 0, "no pending"); // at least 1 user message
         // Compute DB messages
         const newSessionMessages = (0, conversation_1.chatMessagesToSessionMessages)(this.pendingMessages);
         const newLLMMessages = this.llmContext.getPending();
@@ -193,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 !== ` +
@@ -237,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.js

@@ -7,10 +7,9 @@ const errors_1 = require("../protocol/errors");
 const logger = (0, sdk_1.getLogger)();
 const HEARTBEAT_INTERVAL_MS = parseInt(process.env["HEARTBEAT_INTERVAL_MS"] || String(30 * 1000));
 class Connection {
-    constructor(ws, userId, apiKey, heartbeat) {
+    constructor(ws, userId, heartbeat) {
         this.ws = ws;
         this.userId = userId;
-        this.apiKey = apiKey;
         this.heartbeat = heartbeat;
         this.lastMessageTime = Date.now();
     }
@@ -25,16 +24,15 @@ class Connection {
  */
 class ConnectionManager {
     // this is a singleton object and can only be initialized by .init method
-    constructor(apiKeyManager, sessionMessageProcessor) {
-        this.apiKeyManager = apiKeyManager;
+    constructor(sessionMessageProcessor) {
         this.sessionMessageProcessor = sessionMessageProcessor;
         // Connections by id
         this.connections = new Map();
         // userId -> connectionIds
         this.userToConnections = new Map();
     }
-    static init(apiKeyManager, createMsgProcessor) {
-        const connManager = new ConnectionManager(apiKeyManager, {});
+    static init(createMsgProcessor) {
+        const connManager = new ConnectionManager({});
         connManager.sessionMessageProcessor = createMsgProcessor(connManager);
         return connManager;
     }
@@ -42,25 +40,23 @@ class ConnectionManager {
      * Handle new WebSocket connection with handshake protocol
      * TODO: proper error code returning
      */
-    async handleConnection(webSocket, apiKey, req) {
+    async handleConnection(webSocket, token, req) {
         const connectionId = (0, uuid_1.v4)();
         logger.info(`[ConnectionManager] New connection: ${connectionId}`);
         try {
-            // Verify API key
-            const userData = await this.apiKeyManager.verifyApiKey(apiKey);
-            if (!userData) {
-                logger.error(`[ConnectionManager] Invalid API key: ${apiKey}`);
+            const userUUID = await this.sessionMessageProcessor.authenticate(token);
+            if (!userUUID) {
                 throw new errors_1.ChatFatalError("invalid api key");
             }
             // Heartbeat interval
             const heartbeat = setInterval(this.onHeartbeat.bind(this, connectionId), HEARTBEAT_INTERVAL_MS);
             // Register connection
-            this.connections.set(connectionId, new Connection(webSocket, userData.uuid, apiKey, heartbeat));
+            this.connections.set(connectionId, new Connection(webSocket, userUUID, heartbeat));
             // Add to user connections
-            if (!this.userToConnections.has(userData.uuid)) {
-                this.userToConnections.set(userData.uuid, new Set());
+            if (!this.userToConnections.has(userUUID)) {
+                this.userToConnections.set(userUUID, new Set());
             }
-            const userConnections = this.userToConnections.get(userData.uuid);
+            const userConnections = this.userToConnections.get(userUUID);
             if (userConnections) {
                 userConnections.add(connectionId);
             }
@@ -71,7 +67,7 @@ class ConnectionManager {
             const response = {
                 t: "ready",
                 c_id: connectionId,
-                user_uuid: userData.uuid,
+                user_uuid: userUUID,
             };
             // Check if connection still exists before sending
             if (this.connections.has(connectionId)) {
@@ -82,7 +78,7 @@ class ConnectionManager {
                     ` before ready message could be sent`);
             }
             logger.info(`[ConnectionManager] Connection ${connectionId} registered ` +
-                `for user ${userData.uuid}, version: ${clientVersion}`);
+                `for user ${userUUID}, version: ${clientVersion}`);
         }
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
@@ -226,7 +222,7 @@ class ConnectionManager {
                 userConnections.delete(connectionId);
                 if (userConnections.size === 0) {
                     this.userToConnections.delete(conn.userId);
-                    this.sessionMessageProcessor.handleUserDisconnect(conn.userId);
+                    const _ = this.sessionMessageProcessor.handleUserDisconnect(conn.userId);
                 }
             }
             this.connections.delete(connectionId);
@@ -330,23 +326,5 @@ class ConnectionManager {
         const connections = this.userToConnections.get(userId);
         return connections ? Array.from(connections) : [];
     }
-    /**
-     * Implementation of IUserConnectionManager interface.
-     * Get cached api key for a user. This key will not be available
-     * after the user disconnects.
-     */
-    getLiveUserApiKey(userId) {
-        const connectionIds = this.getUserConnections(userId);
-        // Return API key from the first active connection
-        // (all connections for a user should have the same API key)
-        for (const connectionId of connectionIds) {
-            const conn = this.connections.get(connectionId);
-            if (conn) {
-                return conn.apiKey;
-            }
-        }
-        // No active connections for this user
-        return undefined;
-    }
 }
 exports.ConnectionManager = ConnectionManager;

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

@@ -27,7 +27,7 @@ vitest_1.vi.mock("ws");
         // to access private constructor. Since the constructor is private,
         // we need to use type assertion
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        connectionManager = new connectionManager_1.ConnectionManager(mockApiKeyManager.mock, mockSessionRegistry.mock);
+        connectionManager = new connectionManager_1.ConnectionManager(mockSessionRegistry.mock);
     });
     (0, vitest_1.afterEach)(() => {
         vitest_1.vi.restoreAllMocks();
@@ -37,7 +37,7 @@ vitest_1.vi.mock("ws");
             await connectionManager.handleConnection(mockWebSocket.mock, "valid-api-key", { headers: {} });
             // Wait for deferred send
             await new Promise((resolve) => setImmediate(resolve));
-            (0, vitest_1.expect)(mockApiKeyManager.spies.verifyApiKey).toHaveBeenCalledWith("valid-api-key");
+            (0, vitest_1.expect)(mockSessionRegistry.spies.authenticate).toHaveBeenCalledWith("valid-api-key");
             (0, vitest_1.expect)(mockWebSocket.spies.send).toHaveBeenCalledWith(vitest_1.expect.stringMatching(/"t":"ready"/));
         });
         (0, vitest_1.it)("should reject connection with invalid API key", async () => {
@@ -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,
@@ -72,14 +73,6 @@ vitest_1.vi.mock("ws");
             connectionManager.sendToUsers(new Set([mockFactories_1.MOCK_USERS.owner.uuid]), testMessage.d);
             (0, vitest_1.expect)(mockWebSocket.spies.send).toHaveBeenCalledWith(JSON.stringify(testMessage));
         });
-        (0, vitest_1.it)("should return API key for connected user", () => {
-            const apiKey = connectionManager.getLiveUserApiKey(mockFactories_1.MOCK_USERS.owner.uuid);
-            (0, vitest_1.expect)(apiKey).toBe("valid-api-key");
-        });
-        (0, vitest_1.it)("should return undefined for non-existent user", () => {
-            const apiKey = connectionManager.getLiveUserApiKey(mockFactories_1.MOCK_USERS.nonExistent.uuid);
-            (0, vitest_1.expect)(apiKey).toBeUndefined();
-        });
     });
     (0, vitest_1.describe)("connection cleanup", () => {
         (0, vitest_1.beforeEach)(async () => {
@@ -93,9 +86,6 @@ vitest_1.vi.mock("ws");
                 const closeHandler = closeHandlerCall[1];
                 closeHandler();
             }
-            // After cleanup, API key should no longer be available
-            const apiKey = connectionManager.getLiveUserApiKey(mockFactories_1.MOCK_USERS.owner.uuid);
-            (0, vitest_1.expect)(apiKey).toBeUndefined();
         });
         (0, vitest_1.it)("should clean up connection state on error", () => {
             // Get the error handler from mock calls
@@ -105,9 +95,6 @@ vitest_1.vi.mock("ws");
                 const errorHandler = errorHandlerCall[1];
                 errorHandler(new Error("WebSocket error"));
             }
-            // After cleanup, API key should no longer be available
-            const apiKey = connectionManager.getLiveUserApiKey(mockFactories_1.MOCK_USERS.owner.uuid);
-            (0, vitest_1.expect)(apiKey).toBeUndefined();
         });
     });
     (0, vitest_1.describe)("message routing", () => {

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

@@ -5,9 +5,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MESSAGE_INDEX_SUB_INCREMENT = exports.MESSAGE_INDEX_FULL_INCREMENT = exports.MESSAGE_INDEX_START_VALUE = void 0;
 exports.sessionMessagesToNextIndex = sessionMessagesToNextIndex;
 exports.sessionMessagesToLLMConversation = sessionMessagesToLLMConversation;
-exports.sessionMessagesToChatMessages = sessionMessagesToChatMessages;
+exports.userMessageToConversationMessage = userMessageToConversationMessage;
+exports.assistantMessageToConversationMessage = assistantMessageToConversationMessage;
+exports.toolResultToConversationMessage = toolResultToConversationMessage;
+exports.sessionMessagesToConversationMessages = sessionMessagesToConversationMessages;
 exports.llmUserMessageToUserMessageData = llmUserMessageToUserMessageData;
-exports.userMessageToChatMessage = userMessageToChatMessage;
 exports.chatToolResultMessageToSessionMessage = chatToolResultMessageToSessionMessage;
 exports.chatUserMessageToSessionMessage = chatUserMessageToSessionMessage;
 exports.chatAgentMessageToSessionMessage = chatAgentMessageToSessionMessage;
@@ -70,36 +72,82 @@ function sessionMessagesToLLMConversation(sessionMessages) {
     }
     return { firstIndex, conversation };
 }
-function sessionMessagesToChatMessages(sessionMessages, defaultUserUuid, session_id) {
+/**
+ * Convert the DB data (SessionMessage) for a ChatCompletionUserMessageParam
+ * into a ServerUserMessage message.
+ */
+function userMessageToConversationMessage(userMessage, user_uuid, message_idx, session_id) {
+    // The name on the message should be the uuid
+    const userMsgData = llmUserMessageToUserMessageData(userMessage);
+    const user_nickname = userMessage.name;
+    (0, assert_1.strict)(user_nickname, `ChatCompletionUserMessageParam without user ${JSON.stringify(userMessage)}`);
+    const msg = {
+        type: "user_msg",
+        message: userMsgData.message,
+        message_idx,
+        user_uuid,
+        user_nickname,
+        session_id,
+    };
+    if (userMsgData.imageB64) {
+        msg.imageB64 = userMsgData.imageB64;
+    }
+    return msg;
+}
+/**
+ * Convert the DB data (SessionMessage) for a
+ * ChatCompletionAssistantMessageParam into a ServerAgentMessage message.
+ */
+function assistantMessageToConversationMessage(msg, message_idx, session_id) {
+    (0, assert_1.strict)(!msg.audio);
+    return {
+        type: "agent_msg",
+        message: msg,
+        message_idx,
+        session_id,
+    };
+}
+/**
+ * Convert the DB data (SessionMessage) for a ChatCompletionToolMessageParam
+ * into a ServerToolCallResult message.
+ */
+function toolResultToConversationMessage(toolCall, message_idx, session_id) {
+    return {
+        type: "tool_call_result",
+        result: toolCall,
+        message_idx,
+        session_id,
+    };
+}
+/**
+ * Convert a set of SessionMessages (stored in the DB) into Conversation
+ * messages (protocol which can be sent over the wire).
+ */
+function sessionMessagesToConversationMessages(sessionMessages, defaultUserUuid, session_id) {
     const msgs = [];
     for (const sm of sessionMessages) {
         const ccmp = sm.content;
         const message_idx = sm.message_idx;
-        switch (ccmp.role) {
-            case "developer":
-                throw new Error("developer messages not handled yet");
+        const msgRole = ccmp.role;
+        switch (msgRole) {
+            case "system":
+                throw new Error("cannot convert system to ConversationMessage");
             case "assistant":
-                (0, assert_1.strict)(!ccmp.audio);
-                if (ccmp.content) {
-                    msgs.push({
-                        type: "agent_msg",
-                        message: ccmp,
-                        message_idx,
-                        session_id,
-                    });
-                }
-                // TODO: do we want to convert tool calls etc?
+                msgs.push(assistantMessageToConversationMessage(ccmp, message_idx, session_id));
                 break;
             case "user":
                 {
-                    const msg = userMessageToChatMessage(ccmp, message_idx, defaultUserUuid, session_id);
-                    if (msg) {
-                        msgs.push(msg);
-                    }
+                    const user_uuid = sm.sender_uuid || defaultUserUuid;
+                    msgs.push(userMessageToConversationMessage(ccmp, user_uuid, message_idx, session_id));
                 }
                 break;
-            default:
+            case "tool":
+                msgs.push(toolResultToConversationMessage(ccmp, message_idx, session_id));
                 break;
+            default: {
+                const _ = ccmp;
+                throw new Error(`unexpected message role: ${msgRole}`);
+            }
         }
     }
     return msgs;
@@ -122,11 +170,11 @@ function llmUserMessageToUserMessageData(userMessage) {
                 image = content.image_url.url;
                 break;
             case "input_audio":
-                throw new errors_1.ChatErrorMessage("userMessageToChatMessage: audio content not supported");
+                throw new errors_1.ChatErrorMessage("llmUserMessageToUserMessageData: audio content not supported");
             case "file":
-                throw new errors_1.ChatErrorMessage("userMessageToChatMessage: file content not supported");
+                throw new errors_1.ChatErrorMessage("llmUserMessageToUserMessageData: file content not supported");
             default:
-                throw new errors_1.ChatErrorMessage("userMessageToChatMessage: unexpected content.type");
+                throw new errors_1.ChatErrorMessage("llmUserMessageToUserMessageData: unexpected content.type");
         }
     }
     const finalMsg = {
@@ -137,25 +185,6 @@ function llmUserMessageToUserMessageData(userMessage) {
     }
     return finalMsg;
 }
-function userMessageToChatMessage(userMessage, message_idx, defaultUserUuid, session_id) {
-    // The name on the message should be the uuid
-    const userMsgData = llmUserMessageToUserMessageData(userMessage);
-    if (!userMsgData) {
-        return undefined;
-    }
-    const user_uuid = userMessage.name || defaultUserUuid;
-    const msg = {
-        type: "user_msg",
-        message: userMsgData.message,
-        message_idx,
-        user_uuid,
-        session_id,
-    };
-    if (userMsgData.imageB64) {
-        msg.imageB64 = userMsgData.imageB64;
-    }
-    return msg;
-}
 function chatToolResultMessageToSessionMessage(chatMessage) {
     return {
         message_idx: chatMessage.message_idx,
@@ -164,7 +193,7 @@ function chatToolResultMessageToSessionMessage(chatMessage) {
     };
 }
 function chatUserMessageToSessionMessage(chatMessage) {
-    const userMsg = (0, agent_1.createUserMessage)(chatMessage.message, chatMessage.imageB64, chatMessage.user_uuid);
+    const userMsg = (0, agent_1.createUserMessage)(chatMessage.message, chatMessage.imageB64, chatMessage.user_nickname);
     (0, assert_1.strict)(userMsg);
     return {
         message_idx: chatMessage.message_idx,