@xalia/agent 0.5.7 → 0.6.0

package/src/test/dbTestTools.ts

@@ -0,0 +1,153 @@
+import assert from "assert";
+import { AgentProfile } from "../agent/agent";
+import {
+  Database,
+  SUPABASE_LOCAL_KEY,
+  SUPABASE_LOCAL_URL,
+} from "../chat/data/database";
+
+export function getLocalDB(): Database {
+  return new Database(SUPABASE_LOCAL_URL, SUPABASE_LOCAL_KEY);
+}
+
+export const AGENT_PROFILE: AgentProfile = {
+  model: undefined,
+  system_prompt: "You are an unhelpful agent",
+  mcp_settings: {},
+};
+
+export const AGENT_PROFILE_2: AgentProfile = {
+  model: undefined,
+  system_prompt: "You are a very helpful agent.",
+  mcp_settings: { simplecalc: [] },
+};
+
+/// User description
+export type TestUserSpec = {
+  type: "spec";
+  uuid: string;
+  email: string;
+  name: string;
+  api_key: string;
+};
+
+/// User created in the DB
+export type TestUser = {
+  uuid: string;
+  email: string;
+  name: string;
+  api_key: string;
+};
+
+let counter = 1;
+
+export function randomString(length: number = 16): string {
+  const CHARS =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  const array = new Uint8Array(length);
+  crypto.getRandomValues(array);
+  for (let i = 0; i < length; i++) {
+    result += CHARS[array[i] % CHARS.length];
+  }
+  return result;
+}
+
+export function testUserSpec(): TestUserSpec {
+  const uuid = randomString() + String(counter++);
+  const name = `user_${uuid}`;
+  const email = `${name}@host.com`;
+  const api_key = `apikey_${uuid}`;
+  return { type: "spec", uuid, name, email, api_key };
+}
+
+// Test user data that gets reset for each test
+export async function createTestUser(
+  db: Database,
+  user?: TestUserSpec
+): Promise<TestUser> {
+  user = user || testUserSpec();
+  await db.createUser(user.uuid, user.email, user.name);
+  await db.addApiKey(user.uuid, user.api_key, "default", [], true);
+  return user;
+}
+
+export async function cleanupTestUser(
+  db: Database,
+  user: TestUser
+  // api_key: string
+): Promise<void> {
+  try {
+    await db.getClientForTesting().from("users").delete().eq("uuid", user.uuid);
+  } catch (_error) {
+    // Ignore cleanup errors
+  }
+}
+
+export async function createTestSession(
+  db: Database,
+  user1: TestUserSpec
+): Promise<{
+  agentProfileId: string;
+  sessionId: string;
+}> {
+  await createTestUser(db, user1);
+
+  const agentProfile = await db.createAgentProfile(
+    user1.uuid,
+    undefined,
+    "test_profile",
+    AGENT_PROFILE
+  );
+  assert(agentProfile);
+
+  const sessionId = Database.sessionNewUUID();
+  await db.sessionCreate({
+    session_uuid: sessionId,
+    user_uuid: user1.uuid,
+    title: "test_session",
+    agent_profile_uuid: agentProfile.uuid,
+  });
+  assert(sessionId);
+
+  return { agentProfileId: agentProfile.uuid, sessionId };
+}
+
+export async function createTestTeamSession(
+  db: Database,
+  teamUuid: string,
+  testUsers: TestUserSpec[]
+): Promise<{
+  agentProfileId: string;
+  sessionId: string;
+  teamId: string;
+}> {
+  const [user1, _] = await Promise.all([
+    createTestUser(db, testUsers[0]),
+    createTestUser(db, testUsers[1]),
+  ]);
+
+  const agentProfile = await db.createAgentProfile(
+    user1.uuid,
+    undefined,
+    // teamUuid,
+    "test_profile",
+    AGENT_PROFILE
+  );
+  assert(agentProfile);
+
+  const teamId = await db.createTeam(teamUuid, user1.uuid);
+  assert(teamId);
+
+  const sessionId = Database.sessionNewUUID();
+  await db.sessionCreate({
+    session_uuid: sessionId,
+    team_uuid: teamId,
+    user_uuid: user1.uuid,
+    title: "test_session",
+    agent_profile_uuid: agentProfile.uuid,
+  });
+  assert(sessionId);
+
+  return { agentProfileId: agentProfile.uuid, sessionId, teamId };
+}

package/src/test/imageLoad.test.ts

@@ -1,14 +1,15 @@
-import { expect } from "chai";
+/* eslint-disable @typescript-eslint/require-await */
+import { describe, it, expect } from "vitest";
 import { loadImageB64OrUndefined } from "../tool/files";
 import { strict as assert } from "assert";
 
 describe("Image loading", () => {
-  it("convert to data url", async function () {
-    const imageB64 = loadImageB64OrUndefined("frog.png");
-    // console.log(`imageB64: ${imageB64}`);
+  it("convert to data url", async () => {
+    const imageB64 = loadImageB64OrUndefined("test_data/frog.png");
+    console.log(`imageB64: ${imageB64 || ""}`);
 
-    expect(imageB64).to.be.a("string");
+    expect(imageB64).toBeTypeOf("string");
     assert(typeof imageB64 === "string");
-    expect(imageB64.startsWith("data:image/png;base64")).eql(true);
+    expect(imageB64.startsWith("data:image/png;base64")).toBe(true);
   });
 });

package/src/test/mcpServerManager.test.ts

@@ -1,4 +1,5 @@
-import { expect } from "chai";
+/* eslint-disable @typescript-eslint/require-await */
+import { describe, it, expect, afterAll } from "vitest";
 import {
   computeQualifiedName,
   McpServerManager,
@@ -12,7 +13,7 @@ let idx = 0;
 
 function getMcpServerManager(): McpServerManager {
   const tm = new McpServerManager();
-  const name = "mgr" + ++idx;
+  const name = "mgr" + String(++idx);
   managers[name] = tm;
   return tm;
 }
@@ -25,10 +26,12 @@ async function shutdownAll() {
   managers = {};
 }
 
-describe("McpServerManager", async () => {
+describe("McpServerManager", () => {
+  afterAll(shutdownAll);
+
   it("should initialize with correct descriptions", async (): Promise<void> => {
     const tm = getMcpServerManager();
-    await tm.addMcpServer(
+    await tm.addMcpServerWithSSEUrl(
       "simplecalc",
       "http://localhost:5001/mcpservers/sudomcp/simplecalc/session",
       "dummy_key"
@@ -36,17 +39,17 @@ describe("McpServerManager", async () => {
 
     const server = tm.getMcpServer("simplecalc");
     const availableTools = server.getTools();
-    expect(availableTools.length).greaterThan(0);
+    expect(availableTools.length).toBeGreaterThan(0);
 
     // Initially, no tools are enabled.
-    expect(tm.getOpenAITools().length).equal(0);
+    expect(tm.getOpenAITools().length).toBe(0);
 
     // Enable a tool and check we get a description for it.
     const toolName = availableTools[0].name;
     {
       tm.enableTool("simplecalc", toolName);
       const tools = tm.getOpenAITools();
-      expect(tools.length).greaterThan(0);
+      expect(tools.length).toBeGreaterThan(0);
       console.log(`tools: ${JSON.stringify(tools, undefined, 2)}`);
     }
 
@@ -61,9 +64,9 @@ describe("McpServerManager", async () => {
     {
       tm.disableTool("simplecalc", toolName);
       const tools = tm.getOpenAITools();
-      expect(tools.length).equal(0);
+      expect(tools.length).toBe(0);
     }
-  }).timeout(10000);
+  }, 10000);
 
   it("qualified names", async () => {
     const serverName = "server";
@@ -72,27 +75,29 @@ describe("McpServerManager", async () => {
 
     const [_serverName, _toolName] = splitQualifiedName(qualifiedName);
 
-    expect(_serverName).eql(serverName);
-    expect(_toolName).eql(toolName);
+    expect(_serverName).toBe(serverName);
+    expect(_toolName).toBe(toolName);
   });
 
   it("add / remove servers", async () => {
     const tm = getMcpServerManager();
 
-    await tm.addMcpServer(
+    await tm.addMcpServerWithSSEUrl(
       "simplecalc",
       "http://localhost:5001/mcpservers/sudomcp/simplecalc/session",
       "dummy_key"
     );
     tm.enableAllTools("simplecalc");
-    expect(tm.getOpenAITools().length).greaterThan(0);
+    expect(tm.getOpenAITools().length).toBeGreaterThan(0);
 
     // Remove server and check there is no server, and no openai entries.
 
     await tm.removeMcpServer("simplecalc");
-    expect(tm.getOpenAITools().length).equal(0);
+    expect(tm.getOpenAITools().length).toBe(0);
     expect(() => {
       tm.getMcpServer("simplecalc");
-    }).throws();
+    }).toThrow();
   });
-}).afterAll(shutdownAll);
+});
+
+afterAll(shutdownAll);

package/src/test/multiAsyncQueue.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect } from "vitest";
+import { MultiAsyncQueue } from "../chat/utils/multiAsyncQueue";
+
+describe("MultiAsyncQueue", () => {
+  it("should process all waiting elements in one go", async () => {
+    // Place a 1 on the queue. Inside the process fn, place a 2 and 3 on the
+    // queue.  Next invocation of process should see BOTH 2 AND 3.
+
+    const context = { q: undefined as MultiAsyncQueue<number> | undefined };
+    const seen: number[] = [];
+    const process = (elements: number[]): Promise<void> => {
+      console.log(`elements: ${JSON.stringify(elements)}`);
+      expect(context.q).toBeDefined();
+
+      for (const e of elements) {
+        seen.push(e);
+      }
+      if (seen.length === 1) {
+        expect(seen[0]).toBe(1);
+        expect(context.q?.tryEnqueue(2)).toBe(true);
+        expect(context.q?.tryEnqueue(3)).toBe(true);
+      } else if (seen.length === 3) {
+        expect(seen[1]).toBe(2);
+        expect(seen[2]).toBe(3);
+      } else {
+        throw new Error("unexpected elements");
+      }
+
+      return Promise.resolve();
+    };
+
+    context.q = new MultiAsyncQueue<number>(process);
+    expect(context.q).toBeDefined();
+    expect(context.q.tryEnqueue(1)).toBe(true);
+
+    await new Promise<void>((r) => {
+      setTimeout(() => {
+        expect(seen).toEqual([1, 2, 3]);
+        r();
+      }, 100);
+    });
+  });
+
+  it("should reject items when queue is full", async () => {
+    let processCount = 0;
+    let resolveProcess: (() => void) | undefined;
+
+    // Create a process function that blocks until we resolve it
+    const process = async (_elements: number[]): Promise<void> => {
+      processCount++;
+      return new Promise((resolve) => {
+        resolveProcess = resolve;
+      });
+    };
+
+    // Create queue with maxBacklog of 2
+    const queue = new MultiAsyncQueue<number>(process, 2);
+
+    // First item triggers (async) processing
+    expect(queue.tryEnqueue(1)).toBe(true);
+    expect(queue.getLength()).toBe(1); // Item still there until we yield
+    await new Promise((r) => setTimeout(r, 1));
+    expect(queue.getLength()).toBe(0); // Item moved to processing
+
+    // Add items up to backlog limit while first batch is processing
+    expect(queue.tryEnqueue(2)).toBe(true);
+    expect(queue.getLength()).toBe(1);
+    expect(queue.tryEnqueue(3)).toBe(true);
+    expect(queue.getLength()).toBe(2);
+
+    // Should reject when at max capacity
+    expect(queue.tryEnqueue(4)).toBe(false);
+    expect(queue.getLength()).toBe(2);
+
+    // Resolve the first batch processing
+    expect(resolveProcess).toBeDefined();
+    resolveProcess?.();
+
+    // Wait for next batch to start
+    await new Promise((r) => setTimeout(r, 10));
+
+    // Now queue should have processed the first batch and be working on [2, 3]
+    expect(processCount).toBe(2);
+
+    // Should be able to add more items now
+    expect(queue.tryEnqueue(5)).toBe(true);
+
+    // Clean up by resolving the second batch
+    expect(resolveProcess).toBeDefined();
+    resolveProcess?.();
+  });
+
+  it("should handle empty queue correctly", async () => {
+    const processedBatches: number[][] = [];
+
+    const process = (elements: number[]): Promise<void> => {
+      processedBatches.push([...elements]);
+      return Promise.resolve();
+    };
+
+    const queue = new MultiAsyncQueue<number>(process);
+
+    // Queue starts empty
+    expect(queue.getLength()).toBe(0);
+
+    // Enqueue and process one item
+    expect(queue.tryEnqueue(1)).toBe(true);
+
+    await new Promise((r) => setTimeout(r, 10));
+
+    expect(processedBatches).toHaveLength(1);
+    expect(processedBatches[0]).toEqual([1]);
+
+    // Queue should be empty again
+    expect(queue.getLength()).toBe(0);
+
+    // Should be able to enqueue again
+    expect(queue.tryEnqueue(2)).toBe(true);
+
+    await new Promise((r) => setTimeout(r, 10));
+
+    expect(processedBatches).toHaveLength(2);
+    expect(processedBatches[1]).toEqual([2]);
+  });
+});

package/src/test/openaiStreaming.test.ts

@@ -1,4 +1,5 @@
-import { expect } from "chai";
+/* eslint-disable @typescript-eslint/require-await */
+import { describe, it, expect } from "vitest";
 
 import { OpenAI } from "openai";
 import {
@@ -6,7 +7,9 @@ import {
   updateCompletion,
 } from "../agent/openAILLMStreaming";
 
-const TEST_STANDARD: OpenAI.Chat.Completions.ChatCompletionChunk[] = [
+type ChatCompletionChunk = OpenAI.Chat.Completions.ChatCompletionChunk;
+
+const TEST_STANDARD: ChatCompletionChunk[] = [
   {
     id: "chatcmpl-BzBqzVs5w0kU5we3KIUN1Q4FAZXjg",
     choices: [
@@ -34,7 +37,7 @@ const TEST_STANDARD: OpenAI.Chat.Completions.ChatCompletionChunk[] = [
   },
 ];
 
-const TEST_TRAILING_USAGE: OpenAI.Chat.Completions.ChatCompletionChunk[] = [
+const TEST_TRAILING_USAGE: ChatCompletionChunk[] = [
   {
     id: "gen-1753923406-nsIKHyFRoJqkUntBnQTw",
     choices: [
@@ -73,14 +76,63 @@ const TEST_TRAILING_USAGE: OpenAI.Chat.Completions.ChatCompletionChunk[] = [
   },
 ];
 
+const AGGREGATED_MESSAGE: OpenAI.Chat.Completions.ChatCompletion = {
+  id: "gen-1753923406-nsIKHyFRoJqkUntBnQTw",
+  choices: [
+    {
+      message: {
+        content: "test",
+        role: "assistant",
+        refusal: null,
+        tool_calls: undefined,
+      },
+      finish_reason: "stop",
+      index: 0,
+      logprobs: null,
+    },
+  ],
+  created: 1753923406,
+  model: "openai/gpt-4o",
+  object: "chat.completion",
+  service_tier: undefined,
+  system_fingerprint: "fp_a288987b44",
+  usage: {
+    completion_tokens: 50,
+    prompt_tokens: 271,
+    total_tokens: 321,
+    completion_tokens_details: { reasoning_tokens: 0 },
+    prompt_tokens_details: { cached_tokens: 0 },
+  },
+};
+
+const TEST_TRAILING_USAGE_WITH_3_CHUNKS: ChatCompletionChunk[] = [
+  {
+    ...TEST_TRAILING_USAGE[0],
+    choices: [
+      {
+        delta: { content: "test", role: "assistant" },
+        finish_reason: null,
+        index: 0,
+        logprobs: null,
+      },
+    ],
+  },
+  {
+    ...TEST_TRAILING_USAGE[1],
+    choices: [{ ...TEST_TRAILING_USAGE[1].choices[0], finish_reason: "stop" }],
+    usage: undefined,
+  },
+  { ...TEST_TRAILING_USAGE[1], choices: [] },
+];
+
 describe("OpenAI Streaming", () => {
-  it("should support standard termination", async function () {
+  it("should support standard termination", async () => {
     const chunks = TEST_STANDARD;
-    expect(chunks.length).eql(2);
+    expect(chunks.length).toBe(2);
     const { initMessage } = initializeCompletion(chunks[0]);
     updateCompletion(initMessage, chunks[1]);
 
-    expect(initMessage).eql({
+    expect(initMessage).toEqual({
       id: "chatcmpl-BzBqzVs5w0kU5we3KIUN1Q4FAZXjg",
       choices: [
         {
@@ -104,39 +156,22 @@ describe("OpenAI Streaming", () => {
     });
   });
 
-  it("should support trailing usage", async function () {
+  it("should support trailing usage", async () => {
     const chunks = TEST_TRAILING_USAGE;
-    expect(chunks.length).eql(2);
+    expect(chunks.length).toBe(2);
     const { initMessage } = initializeCompletion(chunks[0]);
     updateCompletion(initMessage, chunks[1]);
 
-    expect(initMessage).eql({
-      id: "gen-1753923406-nsIKHyFRoJqkUntBnQTw",
-      choices: [
-        {
-          message: {
-            content: "test",
-            role: "assistant",
-            refusal: null,
-            tool_calls: undefined,
-          },
-          finish_reason: "stop",
-          index: 0,
-          logprobs: null,
-        },
-      ],
-      created: 1753923406,
-      model: "openai/gpt-4o",
-      object: "chat.completion",
-      service_tier: undefined,
-      system_fingerprint: "fp_a288987b44",
-      usage: {
-        completion_tokens: 50,
-        prompt_tokens: 271,
-        total_tokens: 321,
-        completion_tokens_details: { reasoning_tokens: 0 },
-        prompt_tokens_details: { cached_tokens: 0 },
-      },
-    });
+    expect(initMessage).toEqual(AGGREGATED_MESSAGE);
+  });
+
+  it("should support trailing usage with 3 chunks", async () => {
+    const chunks = TEST_TRAILING_USAGE_WITH_3_CHUNKS;
+    expect(chunks.length).toBe(3);
+    const { initMessage } = initializeCompletion(chunks[0]);
+    updateCompletion(initMessage, chunks[1]);
+    updateCompletion(initMessage, chunks[2]);
+
+    expect(initMessage).toEqual(AGGREGATED_MESSAGE);
   });
 });

package/src/test/prompt.test.ts

@@ -1,8 +1,9 @@
-import { expect } from "chai";
+/* eslint-disable @typescript-eslint/require-await */
+import { describe, it, expect } from "vitest";
 import { parsePrompt } from "../tool/commandPrompt";
 
 describe("Prompt", () => {
-  it("should recognise commands", async function () {
+  it("should recognise commands", async () => {
     const expectedResults = {
       "some text  ": { msg: "some text", cmds: undefined },
       ":i image.png some text": { msg: "some text", cmds: ["i", "image.png"] },
@@ -20,7 +21,7 @@ describe("Prompt", () => {
 
     for (const [prompt, expected] of Object.entries(expectedResults)) {
       const res = parsePrompt(prompt);
-      expect(res).eql(expected);
+      expect(res).toEqual(expected);
     }
   });
 });

package/src/test/promptProvider.test.ts

@@ -0,0 +1,33 @@
+import { expect } from "vitest";
+import { SystemPromptProvider } from "../agent/promptProvider";
+
+describe("SystemPromptProvider", () => {
+  it("correctly includes all components", function () {
+    SystemPromptProvider.setGlobalPrompt("global");
+    const pp = new SystemPromptProvider("agent");
+    pp.setFragment("frag1", "FRAG1");
+
+    expect(pp.getSystemPrompt()).eql("global\nagent\nFRAG1");
+  });
+
+  it("handles update/remove of components", function () {
+    SystemPromptProvider.setGlobalPrompt("global");
+    const pp = new SystemPromptProvider("agent");
+    pp.setFragment("frag1", "FRAG1");
+
+    // Update system and frag1.  Add frag2, frag3.  Remove frag3.
+
+    pp.setAgentPrompt("agent2");
+    pp.setFragment("frag1", "FRAG11");
+    pp.setFragment("frag2", "FRAG2");
+    pp.setFragment("frag3", "FRAG3");
+    pp.removeFragment("frag2");
+
+    // Result should contain system, frag1, frag3.  NOT frag2.
+
+    expect(pp.getSystemPrompt().startsWith("global\nagent2\n")).eql(true);
+    expect(pp.getSystemPrompt().includes("FRAG11")).eql(true);
+    expect(pp.getSystemPrompt().includes("FRAG3")).eql(true);
+    expect(pp.getSystemPrompt().includes("FRAG2")).eql(false);
+  });
+});

package/src/test/responseHandler.test.ts

@@ -0,0 +1,78 @@
+import { expect } from "vitest";
+import { ResponseHandler } from "../chat/client/responseHandler";
+
+type ClientA = { type: "a"; client_message_id: string; value: number };
+type ClientB = { type: "b"; client_message_id: string; data: string };
+type ClientMsg = ClientA | ClientB;
+
+type ServerA = { type: "a"; client_message_id: string; value: number };
+type ServerB = { type: "b"; data: string };
+type ServerErr = { type: "err"; client_message_id: string; message: string };
+type ServerMsg = ServerA | ServerB | ServerErr;
+
+describe("ResponseHandler", () => {
+  const req: ClientMsg = {
+    type: "a",
+    client_message_id: "id_a",
+    value: 3,
+  };
+  const response: ServerMsg = {
+    type: "a",
+    client_message_id: "id_a",
+    value: 4,
+  };
+  const otherResponse: ServerMsg = {
+    type: "a",
+    client_message_id: "id_b",
+    value: 4,
+  };
+  const error: ServerMsg = {
+    type: "err",
+    client_message_id: "id_a",
+    message: "error",
+  };
+
+  it("should resolve", async function () {
+    const rh = new ResponseHandler<ClientMsg, ServerMsg>("err", 100);
+    const responseP = rh.waitForResponse(req);
+    rh.onMessage(otherResponse);
+    rh.onMessage(response);
+    rh.onMessage(error);
+
+    expect(await responseP).eql(response);
+
+    // This (late) messages should be ignored.
+    rh.onMessage(otherResponse);
+    rh.onMessage(error);
+    rh.onMessage(response);
+  });
+
+  it("should handle errors", async function () {
+    const rh = new ResponseHandler<ClientMsg, ServerMsg>("err", 100);
+    const responseP = rh.waitForResponse(req);
+    rh.onMessage(otherResponse);
+    rh.onMessage(error);
+    rh.onMessage(response);
+
+    await expect(responseP).rejects.toThrow(error.message);
+
+    // This (late) messages should be ignored.
+    rh.onMessage(otherResponse);
+    rh.onMessage(error);
+    rh.onMessage(response);
+  });
+
+  it("should handle timeouts", async function () {
+    const rh = new ResponseHandler<ClientMsg, ServerMsg>("err", 100);
+    const responseP = rh.waitForResponse(req);
+    rh.onMessage(otherResponse);
+    rh.onMessage({ type: "a", client_message_id: "id_b", value: 4 });
+
+    await expect(responseP).rejects.toThrow();
+
+    // This (late) messages should be ignored.
+    rh.onMessage(otherResponse);
+    rh.onMessage(error);
+    rh.onMessage(response);
+  });
+});