@xalia/agent 0.6.10 → 0.6.11

package/src/test/clientServerConnection.test.ts

@@ -1,205 +0,0 @@
-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 { userSessionCreateData } 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,
-    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.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 = userSessionCreateData(
-        testUserUuid,
-        "Test Session 1",
-        agentProfile1Id
-      );
-      const session1Id = session1CreateData.session_uuid;
-      await db.sessionCreate(session1CreateData);
-      const session2CreateData = userSessionCreateData(
-        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

@@ -1,77 +0,0 @@
-import { expect } from "vitest";
-
-import {
-  CompressingContextManager,
-  createCheckpointMessage,
-} from "../agent/compressingContextManager";
-import { ILLM, MessageParam, UserMessageParam } from "../agent/llm";
-import { MESSAGES, basicContextTest } from "./contextTestTools";
-import { createLLM } from "../agent/agentUtils";
-import { IPlatform } from "../agent/iplatform";
-
-describe("Compression context", () => {
-  it("context compression (basic)", async function () {
-    const ccm = new CompressingContextManager(
-      "sys_prompt",
-      [],
-      () => undefined as unknown as Promise<ILLM> // getLLM
-    );
-    await basicContextTest(ccm);
-  });
-
-  it("context compression", async function () {
-    const llm = await createLLM(
-      "",
-      "",
-      "repeat",
-      false,
-      undefined as unknown as IPlatform
-    );
-    const ccm = new CompressingContextManager("sys_prompt", [], () =>
-      Promise.resolve(llm)
-    );
-
-    // Add first 2 messages
-    let tx = await ccm.startTx([MESSAGES[0] as UserMessageParam]);
-    tx.addMessage(MESSAGES[1]);
-    await ccm.commit(tx);
-
-    // Start the compression
-    const compressionP = ccm.compress();
-
-    // Add more messages and update system prompt
-    tx = await ccm.startTx([MESSAGES[2] as UserMessageParam]);
-    tx.addMessages(MESSAGES.slice(3));
-    await ccm.commit(tx);
-    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: MessageParam[] = [
-      {
-        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 should still be intact
-
-    // const pending = ccm.getPending();
-    // expect(pending).eql(MESSAGES.slice(2));
-  });
-});

package/src/test/context.test.ts

@@ -1,150 +0,0 @@
-import { expect } from "vitest";
-import { strict as assert } from "assert";
-
-import { ContextManagerWithWorkspace } from "../agent/contextWithWorkspace";
-import { createUserMessage } from "../agent/agent";
-import { MessageParam, UserMessageParam } from "../agent/llm";
-import { SystemPromptProvider } from "../agent/promptProvider";
-import { ContextManager } from "../agent/context";
-import { basicContextTest } from "./contextTestTools";
-
-describe("ContextManagerWithWorkspace", () => {
-  const msgs: MessageParam[] = [
-    { role: "user", content: "message A" },
-    { role: "assistant", content: "message B" },
-    { role: "user", content: "message C" },
-    { role: "assistant", content: "message D" },
-  ];
-
-  it("context (basic)", async function () {
-    const cm = new ContextManager("sys_prompt", []);
-    await basicContextTest(cm);
-  });
-
-  it("context with workspace (basic)", async function () {
-    const cm = new ContextManagerWithWorkspace("sys_prompt", []);
-    await basicContextTest(cm);
-  });
-
-  it("should correctly manage messages", async function () {
-    const cm = new ContextManagerWithWorkspace("sys_msg", msgs.slice(0, 2));
-
-    // set workspace and add new user and assistant messages
-    cm.setWorkspace({ role: "user", content: "workspace1" });
-
-    const ctxTx1 = await cm.startTx([msgs[2] as UserMessageParam]);
-    ctxTx1.addMessage(msgs[3]);
-
-    // context writer.  workspace should be before first assistant message
-    expect(ctxTx1.getLLMContext()).eql([
-      { role: "system", content: "sys_msg" },
-      ...msgs.slice(0, 3),
-      { role: "user", content: "workspace1" },
-      ...msgs.slice(3),
-    ]);
-
-    // original cm unchanged
-    expect(cm.getLLMContext()).eql([
-      { role: "system", content: "sys_msg" },
-      ...msgs.slice(0, 2),
-      { role: "user", content: "workspace1" },
-    ]);
-
-    // Commit
-    await cm.commit(ctxTx1);
-
-    // write new messages
-    const lastMsg: MessageParam = {
-      role: "user",
-      content: "hello",
-    };
-    const ctxTx2 = await cm.startTx([lastMsg]);
-    expect(ctxTx2.getLLMContext()).eql([
-      { role: "system", content: "sys_msg" },
-      ...msgs,
-      lastMsg,
-      { role: "user", content: "workspace1" },
-    ]);
-    expect(cm.getLLMContext()).eql([
-      { role: "system", content: "sys_msg" },
-      ...msgs,
-      { role: "user", content: "workspace1" },
-    ]);
-    await cm.commit(ctxTx2);
-
-    // 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", async 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,
-    ]);
-
-    const ctxTx = await cm.startTx([msgs[2] as UserMessageParam]);
-    expect(ctxTx.getLLMContext()).eql([
-      { role: "system", content: "sys_msg" },
-      ...msgs.slice(0, 3),
-      wsMsg,
-    ]);
-    ctxTx.addMessage(msgs[3]);
-    expect(ctxTx.getLLMContext()).eql([
-      { role: "system", content: "sys_msg" },
-      ...msgs.slice(0, 3),
-      wsMsg,
-      msgs[3],
-    ]);
-    expect(ctxTx.newMessages()).eql(msgs.slice(2, 4));
-
-    await cm.commit(ctxTx);
-
-    // context with workspace
-    const ctx1 = cm.getLLMContext();
-    expect(ctx1).eql([{ role: "system", content: "sys_msg" }, ...msgs, wsMsg]);
-  });
-});

package/src/test/contextTestTools.ts

@@ -1,95 +0,0 @@
-import { expect } from "vitest";
-
-import { IContextManager } from "../agent/context";
-import { MessageParam, UserMessageParam } from "../agent/llm";
-
-export const MESSAGES: MessageParam[] = [
-  { 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" },
-];
-
-export async function basicContextTest(cm: IContextManager) {
-  expect(cm.getAgentPrompt()).eql("sys_prompt");
-
-  // Add first 2 messages
-  let tx = await cm.startTx([MESSAGES[0] as UserMessageParam]);
-  tx.addMessage(MESSAGES[1]);
-  expect(tx.getLLMContext()).eql([
-    {
-      role: "system",
-      content: "sys_prompt",
-    },
-    MESSAGES[0],
-    MESSAGES[1],
-  ]);
-  await cm.commit(tx);
-
-  // Add more messages
-  tx = await cm.startTx([MESSAGES[2] as UserMessageParam]);
-  expect(tx.getLLMContext()).eql([
-    {
-      role: "system",
-      content: "sys_prompt",
-    },
-    MESSAGES[0],
-    MESSAGES[1],
-    MESSAGES[2],
-  ]);
-  tx.addMessages(MESSAGES.slice(3));
-  expect(tx.getLLMContext()).eql([
-    {
-      role: "system",
-      content: "sys_prompt",
-    },
-    MESSAGES[0],
-    MESSAGES[1],
-    MESSAGES[2],
-    MESSAGES[3],
-    MESSAGES[4],
-    MESSAGES[5],
-  ]);
-  await cm.commit(tx);
-
-  // Update system prompt
-  cm.setAgentPrompt("New system prompt");
-
-  // Wait for compression to complete, then get the new context
-  const context = cm.getLLMContext();
-
-  // Expect
-  //   - callback happened
-  //   - new context is as expected
-
-  const expectContext: MessageParam[] = [
-    {
-      role: "system",
-      content: "New system prompt",
-    },
-    MESSAGES[0], // 400
-    MESSAGES[1], // 500
-    MESSAGES[2], // 400
-    MESSAGES[3], // 500
-    MESSAGES[4], // 501
-    MESSAGES[5], // 502
-  ];
-
-  expect(context).eql(expectContext);
-}

package/src/test/conversation.test.ts

@@ -1,109 +0,0 @@
-import { expect } from "vitest";
-import {
-  AssistantMessageParam,
-  MessageParam,
-  UserMessageParam,
-} from "../agent/llm";
-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: AssistantMessageParam[] = [
-  { role: "assistant", content: "Message 0" },
-  { role: "assistant", content: "Message 1" },
-  { role: "assistant", content: "Message 2" },
-];
-
-const USER: UserMessageParam[] = [
-  { 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 MessageParam,
-        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 MessageParam,
-        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);
-  });
-});