@xalia/agent 0.5.8 → 0.6.0

package/src/chat/server/conversation.ts

@@ -0,0 +1,269 @@
+/// Abstraction of LLM messages (suitable for passing conversations to the
+/// LLM) and SessionMessage (saved in the DB)
+
+import { strict as assert } from "assert";
+
+import {
+  ChatCompletionMessageParam,
+  ChatCompletionUserMessageParam,
+  createUserMessage,
+} from "../../agent/agent";
+import { SessionMessage, UserMessageData } from "../data/dataModels";
+import {
+  ServerAgentMessage,
+  ServerToolCallResult,
+  ServerUserMessage,
+} from "../protocol/messages";
+import { ChatErrorMessage } from "../protocol/errors";
+
+export const MESSAGE_INDEX_START_VALUE = 0;
+export const MESSAGE_INDEX_FULL_INCREMENT = 100;
+export const 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
+assert(
+  MESSAGE_INDEX_START_VALUE ===
+    ((MESSAGE_INDEX_START_VALUE / MESSAGE_INDEX_FULL_INCREMENT) | 0) *
+      MESSAGE_INDEX_FULL_INCREMENT
+);
+
+export type ConversationMessage =
+  | ServerUserMessage
+  | ServerAgentMessage
+  | ServerToolCallResult;
+
+/**
+ * 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.
+ */
+export function sessionMessagesToNextIndex(
+  sessionMessages: SessionMessage[]
+): number {
+  const numMessages = sessionMessages.length;
+  if (numMessages === 0) {
+    return 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 + MESSAGE_INDEX_FULL_INCREMENT) / MESSAGE_INDEX_FULL_INCREMENT;
+  const floorNumFullIncrements = numFullIncrements | 0;
+  return floorNumFullIncrements * 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.
+ */
+export function sessionMessagesToLLMConversation(
+  sessionMessages: SessionMessage[]
+): { firstIndex: number; conversation: ChatCompletionMessageParam[] } {
+  const conversation = [];
+  let started = false;
+  let firstIndex: number = -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 };
+}
+
+export function sessionMessagesToChatMessages(
+  sessionMessages: SessionMessage[],
+  defaultUserUuid: string,
+  session_id: string
+): (ServerUserMessage | ServerAgentMessage)[] {
+  const msgs: (ServerUserMessage | ServerAgentMessage)[] = [];
+  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":
+        assert(!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;
+}
+
+export function llmUserMessageToUserMessageData(
+  userMessage: ChatCompletionUserMessageParam
+): UserMessageData | undefined {
+  if (typeof userMessage.content === "string") {
+    return {
+      message: userMessage.content,
+    };
+  }
+
+  let message = "";
+  let image: string | undefined = undefined;
+  for (const content of userMessage.content) {
+    switch (content.type) {
+      case "text":
+        message += content.text;
+        break;
+      case "image_url":
+        assert(!image, "only one image per message supported");
+        image = content.image_url.url;
+        break;
+      case "input_audio":
+        throw new ChatErrorMessage(
+          "userMessageToChatMessage: audio content not supported"
+        );
+      case "file":
+        throw new ChatErrorMessage(
+          "userMessageToChatMessage: file content not supported"
+        );
+      default:
+        throw new ChatErrorMessage(
+          "userMessageToChatMessage: unexpected content.type"
+        );
+    }
+  }
+
+  const finalMsg: UserMessageData = {
+    message,
+  };
+  if (image) {
+    finalMsg.imageB64 = image;
+  }
+  return finalMsg;
+}
+
+export function userMessageToChatMessage(
+  userMessage: ChatCompletionUserMessageParam,
+  message_idx: number,
+  defaultUserUuid: string,
+  session_id: string
+): ServerUserMessage | undefined {
+  // 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: ServerUserMessage = {
+    type: "user_msg",
+    message: userMsgData.message,
+    message_idx,
+    user_uuid,
+    session_id,
+  };
+  if (userMsgData.imageB64) {
+    msg.imageB64 = userMsgData.imageB64;
+  }
+  return msg;
+}
+
+export function chatToolResultMessageToSessionMessage(
+  chatMessage: ServerToolCallResult
+): SessionMessage {
+  return {
+    message_idx: chatMessage.message_idx,
+    is_for_llm: true,
+    content: chatMessage.result,
+  };
+}
+
+export function chatUserMessageToSessionMessage(
+  chatMessage: ServerUserMessage
+): SessionMessage {
+  const userMsg = createUserMessage(
+    chatMessage.message,
+    chatMessage.imageB64,
+    chatMessage.user_uuid
+  );
+  assert(userMsg);
+  return {
+    message_idx: chatMessage.message_idx,
+    is_for_llm: true,
+    sender_uuid: chatMessage.user_uuid,
+    content: userMsg,
+  };
+}
+
+export function chatAgentMessageToSessionMessage(
+  chatMessage: ServerAgentMessage
+): SessionMessage {
+  return {
+    message_idx: chatMessage.message_idx,
+    is_for_llm: true,
+    content: chatMessage.message,
+  };
+}
+
+export function chatMessagesToSessionMessages(
+  chatMessages: ConversationMessage[]
+): SessionMessage[] {
+  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: never = c;
+        return exhaustive;
+      }
+    }
+  });
+}

package/src/chat/server/errorUtils.ts

@@ -0,0 +1,28 @@
+/**
+ * Extract error string from an unknown error.  Handles raw strings, `Error`
+ * objects, DB errors and falls back to outputting as String and JSON.
+ */
+export function getErrorString(err: unknown): string {
+  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 as {
+    code: string | undefined;
+    details: string | undefined;
+  };
+  if (dbErr.code && dbErr.details) {
+    return "db error: " + dbErr.details;
+  }
+
+  return (
+    `unknown err (${typeof err}, ${String(err?.constructor?.name)}) ` +
+    JSON.stringify(err) +
+    "String(err)"
+  );
+}