@xalia/agent 0.5.8 → 0.6.1

package/src/test/clientServerConnection.test.ts

@@ -0,0 +1,207 @@
+import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
+import { Server } from "ws";
+import { Connection } from "../chat/client/connection";
+import { runServer } from "../chat/server/server";
+import { Database } from "../chat/data/database";
+import { getLogger } from "@xalia/xmcp/sdk";
+import { SUPABASE_LOCAL_KEY, SUPABASE_LOCAL_URL } from "../chat/data/database";
+import {
+  ClientControlGetSessionList,
+  ServerControlSessionList,
+} from "../chat/protocol/messages";
+import { userSessionDataCreate } from "../chat/server/sessionRegistry";
+
+// Mock uuid to have predictable client message IDs
+vi.mock("uuid", () => ({
+  v4: () => "mock-uuid-123",
+}));
+
+const logger = getLogger();
+
+describe("Client-Server WebSocket Integration", () => {
+  let server: Server;
+  let db: Database;
+  const serverPort = 5105; // Different port to avoid conflicts
+  // Test API key data
+  const testApiKey = "integration_test";
+  const testUserUuid = "test_user_0";
+  const testUserName = "default";
+  const testScopes: string[] = [];
+  // Mock environment variables for server
+  const mockEnv = {
+    SUPABASE_URL: SUPABASE_LOCAL_URL,
+    SUPABASE_KEY: SUPABASE_LOCAL_KEY,
+    LLM_URL: "http://localhost:8080", // not used in this test
+    XMCP_URL: "http://localhost:8081", // not used in this test
+  };
+  beforeAll(async () => {
+    // Set up environment variables
+    Object.assign(process.env, mockEnv);
+    // Initialize database connection
+    db = new Database(mockEnv.SUPABASE_URL, mockEnv.SUPABASE_KEY);
+    // Try to insert test data, but don't fail if there are database issues
+    try {
+      await cleanupTestData();
+      await insertTestApiKey();
+      logger.info("[Test] Test data setup completed successfully");
+    } catch (error) {
+      logger.warn(
+        "[Test] Test data setup failed - will test with existing data:",
+        error
+      );
+    }
+    // Start the real server using runServer
+    server = await runServer(
+      serverPort,
+      mockEnv.SUPABASE_URL,
+      mockEnv.SUPABASE_KEY,
+      mockEnv.LLM_URL,
+      mockEnv.XMCP_URL
+    );
+    // Wait for server to be ready
+    await new Promise((resolve) => setTimeout(resolve, 500));
+  });
+  async function cleanupTestData() {
+    try {
+      // Delete test API key first (foreign key constraint)
+      await db
+        .getClientForTesting()
+        .from("api_keys")
+        .delete()
+        .eq("api_key", testApiKey);
+      // Delete test user
+      await db
+        .getClientForTesting()
+        .from("users")
+        .delete()
+        .eq("uuid", testUserUuid);
+      logger.info("[Test] Cleaned up existing test data");
+    } catch (error) {
+      logger.warn(
+        "[Test] Error during cleanup (expected if no data exists):",
+        error
+      );
+    }
+  }
+  async function insertTestApiKey() {
+    try {
+      // Use Database class methods which include timezone handling
+      await db.createUser(
+        testUserUuid,
+        "test@example.com",
+        testUserName,
+        "UTC"
+      );
+      logger.info("[Test] User created successfully");
+      await db.addApiKey(
+        testUserUuid,
+        testApiKey,
+        testUserName,
+        testScopes,
+        true // is_default
+      );
+    } catch (error) {
+      logger.error("[Test] Database method insert failed:", error);
+      throw error;
+    }
+  }
+  afterAll(async () => {
+    // Clean up test data
+    await cleanupTestData();
+    // Close server
+    server.close();
+  });
+  describe("Connection Setup and List Sessions", () => {
+    it("should establish connection with valid API key", async () => {
+      // Inject test agent profiles and sessions into the database
+      const agentProfile1 = await db.createAgentProfile(
+        testUserUuid,
+        undefined,
+        "Test agent profile 1",
+        {
+          model: undefined,
+          system_prompt: "You are a test agent",
+          mcp_settings: {},
+        }
+      );
+      const agentProfile2 = await db.createAgentProfile(
+        testUserUuid,
+        undefined,
+        "Test agent profile 2",
+        {
+          model: undefined,
+          system_prompt: "You are a test agent",
+          mcp_settings: {},
+        }
+      );
+      if (!agentProfile1 || !agentProfile2) {
+        throw new Error("Failed to create agent profiles");
+      }
+      const agentProfile1Id = agentProfile1.uuid;
+      const agentProfile2Id = agentProfile2.uuid;
+      const session1CreateData = userSessionDataCreate(
+        testUserUuid,
+        "Test Session 1",
+        agentProfile1Id
+      );
+      const session1Id = session1CreateData.session_uuid;
+      await db.sessionCreate(session1CreateData);
+      const session2CreateData = userSessionDataCreate(
+        testUserUuid,
+        "Test Session 2",
+        agentProfile2Id
+      );
+      const session2Id = session2CreateData.session_uuid;
+      await db.sessionCreate(session2CreateData);
+      // Log session creation for debugging
+      logger.info(`[Test] Created sessions: ${session1Id}, ${session2Id}`);
+      const client = new Connection({
+        url: `ws://localhost:${String(serverPort)}`,
+        token: testApiKey,
+      });
+      // Wait for session_list response
+      const responsePromise = new Promise<ServerControlSessionList>(
+        (resolve) => {
+          client.on("control_session_list", (msg) => {
+            resolve(msg as ServerControlSessionList);
+          });
+        }
+      );
+      await client.connect();
+      expect(client.getState()).toBe("ready");
+      client.send({
+        type: "control_get_session_list",
+        client_message_id: "test-msg-id",
+      } as ClientControlGetSessionList);
+      const response = await responsePromise;
+      expect(response.type).toBe("control_session_list");
+      expect(response.user_sessions).toBeDefined();
+      expect(response.user_sessions.length).toBe(2);
+      // Verify session details
+      const sessionIds = response.user_sessions.map((s) => s.session_uuid);
+      expect(sessionIds).toContain(session1Id);
+      expect(sessionIds).toContain(session2Id);
+      const session1Data = response.user_sessions.find(
+        (s) => s.session_uuid === session1Id
+      );
+      expect(session1Data?.title).toBe("Test Session 1");
+      const session2Data = response.user_sessions.find(
+        (s) => s.session_uuid === session2Id
+      );
+      expect(session2Data?.title).toBe("Test Session 2");
+      client.close();
+    }, 15000);
+  });
+  describe("Authentication Error Handling", () => {
+    it("should handle invalid API key gracefully", async () => {
+      const invalidApiKey = "invalid-test-key";
+      const client = new Connection({
+        url: `ws://localhost:${String(serverPort)}`,
+        token: invalidApiKey,
+      });
+      await expect(client.connect()).rejects.toThrow();
+      expect(client.getState()).toBe("closed");
+      client.close();
+    }, 4000);
+  });
+});

package/src/test/compressingContextManager.test.ts

@@ -0,0 +1,82 @@
+import { expect } from "vitest";
+
+import {
+  CompressingContextManager,
+  createCheckpointMessage,
+} from "../agent/compressingContextManager";
+import { ChatCompletionMessageParam } from "../agent/agent";
+
+const MESSAGES: ChatCompletionMessageParam[] = [
+  { role: "user", content: "msg200" },
+  { role: "assistant", content: "msg300" },
+  { role: "user", content: "msg400" },
+  {
+    role: "assistant",
+    content: "msg500",
+    tool_calls: [
+      {
+        id: "tool_call_0",
+        type: "function",
+        function: { name: "tool1", arguments: "" },
+      },
+    ],
+  },
+  {
+    role: "tool",
+    content: "msg501",
+    tool_call_id: "tool_call_0",
+  },
+  { role: "assistant", content: "msg502" },
+];
+
+describe("Compression context", () => {
+  it("context compression", async function () {
+    const ccm = new CompressingContextManager(
+      "sys_prompt",
+      [],
+      "", // llmUrl
+      "repeat", // llmModel
+      "" // llmApiKey
+    );
+
+    // Add first 2 messages
+    ccm.addMessages(MESSAGES.slice(0, 2));
+    ccm.commit();
+
+    // Start the compression
+    const compressionP = ccm.compress();
+
+    // Add more messages and update system prompt
+    ccm.addMessages(MESSAGES.slice(2));
+    ccm.setAgentPrompt("New system prompt");
+
+    // Wait for compression to complete, then get the new context
+    const summary = await compressionP;
+    const context = ccm.getLLMContext();
+
+    // Expect
+    //   - callback happened
+    //   - new context is as expected
+
+    const expectSummary = "Message number 0";
+    const expectContext: ChatCompletionMessageParam[] = [
+      {
+        role: "system",
+        content: "New system prompt",
+      },
+      createCheckpointMessage(expectSummary),
+      MESSAGES[2], // 400
+      MESSAGES[3], // 500
+      MESSAGES[4], // 501
+      MESSAGES[5], // 502
+    ];
+
+    expect(summary).eql(expectSummary);
+    expect(context).eql(expectContext);
+
+    // Pending messages shoudl still be intact
+
+    const pending = ccm.getPending();
+    expect(pending).eql(MESSAGES.slice(2));
+  });
+});

package/src/test/context.test.ts

@@ -0,0 +1,105 @@
+import { expect } from "vitest";
+import { strict as assert } from "assert";
+
+import { ContextManagerWithWorkspace } from "../agent/context";
+import { ChatCompletionMessageParam, createUserMessage } from "../agent/agent";
+import { SystemPromptProvider } from "../agent/promptProvider";
+
+describe("ContextManagerWithWorkspace", () => {
+  const msgs: ChatCompletionMessageParam[] = [
+    { role: "user", content: "message A" },
+    { role: "assistant", content: "message B" },
+    { role: "user", content: "message C" },
+    { role: "assistant", content: "message D" },
+  ];
+
+  it("should correctly manage messages", function () {
+    const cm = new ContextManagerWithWorkspace("sys_msg", msgs.slice(0, 2));
+
+    // set workspace and add new messages
+    cm.setWorkspace({ role: "user", content: "workspace1" });
+    cm.addMessages(msgs.slice(2));
+
+    // context with workspace
+    const ctx1 = cm.getLLMContext();
+    expect(ctx1).eql([
+      { role: "system", content: "sys_msg" },
+      ...msgs,
+      { role: "user", content: "workspace1" },
+    ]);
+
+    // context with new message and workspace
+    const lastMsg: ChatCompletionMessageParam = {
+      role: "user",
+      content: "hello",
+    };
+    cm.addMessage(lastMsg);
+    const ctx2 = cm.getLLMContext();
+    expect(ctx2).eql([
+      { role: "system", content: "sys_msg" },
+      ...msgs,
+      lastMsg,
+      { role: "user", content: "workspace1" },
+    ]);
+
+    // context without workspace
+    cm.setWorkspace(undefined);
+    const ctx3 = cm.getLLMContext();
+    expect(ctx3).eql([
+      { role: "system", content: "sys_msg" },
+      ...msgs,
+      lastMsg,
+    ]);
+  });
+
+  it("correctly includes all system prompt components", function () {
+    const cm = new ContextManagerWithWorkspace(
+      "agent_prompt",
+      msgs.slice(0, 2)
+    );
+    SystemPromptProvider.setGlobalPrompt("global");
+    cm.setPromptFragment("frag1", "FRAG1");
+
+    // Get the agentPrompt and llmContext, then undo the global prompt change
+    // (to ensure other tests are affected, even if this one fails).
+
+    const agentPrompt = cm.getAgentPrompt();
+    const llmContext = cm.getLLMContext();
+    SystemPromptProvider.setGlobalPrompt(undefined);
+
+    expect(agentPrompt).eql("agent_prompt");
+    expect(llmContext[0].content).eql("global\nagent_prompt\nFRAG1");
+  });
+
+  it("handles rich workspace messages", function () {
+    const cm = new ContextManagerWithWorkspace("sys_msg", msgs.slice(0, 2));
+
+    expect(cm.getLLMContext()).eql([
+      { role: "system", content: "sys_msg" },
+      ...msgs.slice(0, 2),
+    ]);
+
+    // set workspace and add new messages
+    const wsMsg = createUserMessage(
+      "text",
+      "data:image/png;base64;adsfadsfadf",
+      "user_name"
+    );
+    assert(wsMsg);
+    assert(wsMsg.content);
+    assert(typeof wsMsg.content !== "string");
+    cm.setWorkspace(wsMsg);
+
+    expect(cm.getLLMContext()).eql([
+      { role: "system", content: "sys_msg" },
+      ...msgs.slice(0, 2),
+      wsMsg,
+    ]);
+
+    cm.addMessages(msgs.slice(2));
+
+    // context with workspace
+    const ctx1 = cm.getLLMContext();
+    expect(ctx1).eql([{ role: "system", content: "sys_msg" }, ...msgs, wsMsg]);
+  });
+});

package/src/test/conversation.test.ts

@@ -0,0 +1,109 @@
+import { expect } from "vitest";
+import {
+  ChatCompletionAssistantMessageParam,
+  ChatCompletionMessageParam,
+  ChatCompletionUserMessageParam,
+} from "../agent/agent";
+import {
+  MESSAGE_INDEX_FULL_INCREMENT,
+  MESSAGE_INDEX_SUB_INCREMENT,
+  sessionMessagesToLLMConversation,
+  sessionMessagesToNextIndex,
+} from "../chat/server/conversation";
+import { SessionMessage } from "../chat/data/dataModels";
+
+// Fake conversation values.
+const AGENT: ChatCompletionAssistantMessageParam[] = [
+  { role: "assistant", content: "Message 0" },
+  { role: "assistant", content: "Message 1" },
+  { role: "assistant", content: "Message 2" },
+];
+
+const USER: ChatCompletionUserMessageParam[] = [
+  { role: "user", content: "Message 0", name: "userA" },
+  { role: "user", content: "Message 1", name: "userA" },
+  { role: "user", content: "Message 2", name: "userA" },
+];
+
+describe("Conversation tools", () => {
+  it("sessionMessagesToLLMConversation handles empty case", () => {
+    const nextMessageIdx = sessionMessagesToNextIndex([]);
+    const { firstIndex, conversation } = sessionMessagesToLLMConversation([]);
+
+    expect(nextMessageIdx).eql(0);
+    expect(firstIndex).eql(-1);
+    expect(conversation).eql([]);
+  });
+
+  it("sessionMessagesToLLMConversation extracts LLM messages", () => {
+    const messages: SessionMessage[] = [
+      {
+        message_idx: 0,
+        sender_uuid: "userA",
+        content: USER[0],
+        is_for_llm: true,
+      },
+      {
+        message_idx: 100,
+        content: {} as unknown as ChatCompletionMessageParam,
+        is_for_llm: false,
+      },
+      {
+        message_idx: 101,
+        content: AGENT[0],
+        is_for_llm: true,
+      },
+    ];
+    const expectConversation = [USER[0], AGENT[0]];
+    const expectNextIdx = 2 * MESSAGE_INDEX_FULL_INCREMENT;
+    const expectFirstIdx = 0;
+
+    const nextMessageIdx = sessionMessagesToNextIndex(messages);
+    const nextMessageIdx100 = sessionMessagesToNextIndex(messages.slice(0, 2));
+    const { firstIndex, conversation } =
+      sessionMessagesToLLMConversation(messages);
+    expect(conversation).eql(expectConversation);
+    expect(nextMessageIdx).eql(expectNextIdx);
+    expect(nextMessageIdx100).eql(expectNextIdx);
+    expect(firstIndex).eql(expectFirstIdx);
+  });
+
+  it("sessionMessagesToLLMConversation skips leading invalid", () => {
+    const messages: SessionMessage[] = [
+      {
+        message_idx: 3 * MESSAGE_INDEX_FULL_INCREMENT,
+        content: AGENT[0],
+        is_for_llm: true,
+      },
+      {
+        // Should be identified as the first message, since we can't start
+        // with an agent message
+        message_idx: 4 * MESSAGE_INDEX_FULL_INCREMENT,
+        sender_uuid: "userA",
+        content: USER[0],
+        is_for_llm: true,
+      },
+      {
+        message_idx: 5 * MESSAGE_INDEX_FULL_INCREMENT,
+        content: {} as unknown as ChatCompletionMessageParam,
+        is_for_llm: false,
+      },
+      {
+        message_idx:
+          5 * MESSAGE_INDEX_FULL_INCREMENT + 3 * MESSAGE_INDEX_SUB_INCREMENT,
+        content: AGENT[1],
+        is_for_llm: true,
+      },
+    ];
+    const expectConversation = [USER[0], AGENT[1]];
+    const expectNextIdx = 6 * MESSAGE_INDEX_FULL_INCREMENT;
+    const expectFirstIdx = 4 * MESSAGE_INDEX_FULL_INCREMENT;
+
+    const nextMessageIdx = sessionMessagesToNextIndex(messages);
+    const { firstIndex, conversation } =
+      sessionMessagesToLLMConversation(messages);
+    expect(conversation).eql(expectConversation);
+    expect(nextMessageIdx).eql(expectNextIdx);
+    expect(firstIndex).eql(expectFirstIdx);
+  });
+});