@xalia/agent 0.5.7 → 0.6.0

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

@@ -0,0 +1,198 @@
+"use strict";
+/// Abstraction of LLM messages (suitable for passing conversations to the
+/// LLM) and SessionMessage (saved in the DB)
+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.llmUserMessageToUserMessageData = llmUserMessageToUserMessageData;
+exports.userMessageToChatMessage = userMessageToChatMessage;
+exports.chatToolResultMessageToSessionMessage = chatToolResultMessageToSessionMessage;
+exports.chatUserMessageToSessionMessage = chatUserMessageToSessionMessage;
+exports.chatAgentMessageToSessionMessage = chatAgentMessageToSessionMessage;
+exports.chatMessagesToSessionMessages = chatMessagesToSessionMessages;
+const assert_1 = require("assert");
+const agent_1 = require("../../agent/agent");
+const errors_1 = require("../protocol/errors");
+exports.MESSAGE_INDEX_START_VALUE = 0;
+exports.MESSAGE_INDEX_FULL_INCREMENT = 100;
+exports.MESSAGE_INDEX_SUB_INCREMENT = 1;
+//     MESSAGE_INDEX_START_VALUE = N * MESSAGE_INDEX_FULL_INCREMENT
+// <=> MESSAGE_INDEX_START_VALUE =
+//                floor(MESSAGE_INDEX_START_VALUE/MESSAGE_INDEX_FULL_INCREMENT)
+//                * MESSAGE_INDEX_FULL_INCREMENT
+(0, assert_1.strict)(exports.MESSAGE_INDEX_START_VALUE ===
+    ((exports.MESSAGE_INDEX_START_VALUE / exports.MESSAGE_INDEX_FULL_INCREMENT) | 0) *
+        exports.MESSAGE_INDEX_FULL_INCREMENT);
+/**
+ * Compute the next message index to assign.  Note, this is non-trivial since
+ * we use a 'BIGINT with gaps' strategy to ensure that multi-part agent
+ * messages can be inserted into the conversation.
+ */
+function sessionMessagesToNextIndex(sessionMessages) {
+    const numMessages = sessionMessages.length;
+    if (numMessages === 0) {
+        return exports.MESSAGE_INDEX_START_VALUE;
+    }
+    const lastIdx = sessionMessages[numMessages - 1].message_idx;
+    // We must compute lastIdx + 1 rounded up to the nearest
+    // MESSAGE_INDEX_FULL_INCREMENT
+    const numFullIncrements = (lastIdx + exports.MESSAGE_INDEX_FULL_INCREMENT) / exports.MESSAGE_INDEX_FULL_INCREMENT;
+    const floorNumFullIncrements = numFullIncrements | 0;
+    return floorNumFullIncrements * exports.MESSAGE_INDEX_FULL_INCREMENT;
+}
+/**
+ * The conversation history may be truncated.  In this case, discard any
+ * messages which do not make sense (e.g. leading Agent messages).  Inform the
+ * caller of the first messages to be included in the conversation, so it can
+ * request messages further back in history if required.
+ */
+function sessionMessagesToLLMConversation(sessionMessages) {
+    const conversation = [];
+    let started = false;
+    let firstIndex = -1;
+    for (const msg of sessionMessages) {
+        if (!msg.is_for_llm) {
+            continue;
+        }
+        const llmMsg = msg.content;
+        // Skip leading messages which are not the users.  Record the index of the
+        // first message we actually use.
+        if (!started) {
+            if (llmMsg.role !== "user") {
+                continue;
+            }
+            started = true;
+            firstIndex = msg.message_idx;
+        }
+        conversation.push(llmMsg);
+    }
+    return { firstIndex, conversation };
+}
+function sessionMessagesToChatMessages(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");
+            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?
+                break;
+            case "user":
+                {
+                    const msg = userMessageToChatMessage(ccmp, message_idx, defaultUserUuid, session_id);
+                    if (msg) {
+                        msgs.push(msg);
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    return msgs;
+}
+function llmUserMessageToUserMessageData(userMessage) {
+    if (typeof userMessage.content === "string") {
+        return {
+            message: userMessage.content,
+        };
+    }
+    let message = "";
+    let image = undefined;
+    for (const content of userMessage.content) {
+        switch (content.type) {
+            case "text":
+                message += content.text;
+                break;
+            case "image_url":
+                (0, assert_1.strict)(!image, "only one image per message supported");
+                image = content.image_url.url;
+                break;
+            case "input_audio":
+                throw new errors_1.ChatErrorMessage("userMessageToChatMessage: audio content not supported");
+            case "file":
+                throw new errors_1.ChatErrorMessage("userMessageToChatMessage: file content not supported");
+            default:
+                throw new errors_1.ChatErrorMessage("userMessageToChatMessage: unexpected content.type");
+        }
+    }
+    const finalMsg = {
+        message,
+    };
+    if (image) {
+        finalMsg.imageB64 = image;
+    }
+    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,
+        is_for_llm: true,
+        content: chatMessage.result,
+    };
+}
+function chatUserMessageToSessionMessage(chatMessage) {
+    const userMsg = (0, agent_1.createUserMessage)(chatMessage.message, chatMessage.imageB64, chatMessage.user_uuid);
+    (0, assert_1.strict)(userMsg);
+    return {
+        message_idx: chatMessage.message_idx,
+        is_for_llm: true,
+        sender_uuid: chatMessage.user_uuid,
+        content: userMsg,
+    };
+}
+function chatAgentMessageToSessionMessage(chatMessage) {
+    return {
+        message_idx: chatMessage.message_idx,
+        is_for_llm: true,
+        content: chatMessage.message,
+    };
+}
+function chatMessagesToSessionMessages(chatMessages) {
+    return chatMessages.map((c) => {
+        switch (c.type) {
+            case "user_msg":
+                return chatUserMessageToSessionMessage(c);
+            case "agent_msg":
+                return chatAgentMessageToSessionMessage(c);
+            case "tool_call_result":
+                return chatToolResultMessageToSessionMessage(c);
+            default: {
+                const exhaustive = c;
+                return exhaustive;
+            }
+        }
+    });
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErrorString = getErrorString;
+/**
+ * Extract error string from an unknown error.  Handles raw strings, `Error`
+ * objects, DB errors and falls back to outputting as String and JSON.
+ */
+function getErrorString(err) {
+    if (typeof err === "string") {
+        return err;
+    }
+    if (err instanceof Error) {
+        // Generic Error.  For now just send messages, don't close.
+        return "internal server error: " + err.message;
+    }
+    const dbErr = err;
+    if (dbErr.code && dbErr.details) {
+        return "db error: " + dbErr.details;
+    }
+    return (`unknown err (${typeof err}, ${String(err?.constructor?.name)}) ` +
+        JSON.stringify(err) +
+        "String(err)");
+}