@teneo-protocol/sdk 2.2.2 → 3.0.0

package/tests/unit/managers/agent-room-manager.test.ts

@@ -4,7 +4,11 @@
  */
 
 import { describe, it, expect, beforeEach, vi } from "vitest";
-import { AgentRoomManager, AgentRoomInfo } from "../../../src/managers/agent-room-manager";
+import {
+  AgentRoomManager,
+  AgentRoomInfo,
+  PaginatedAgentsResult
+} from "../../../src/managers/agent-room-manager";
 import { RoomManagementManager } from "../../../src/managers/room-management-manager";
 import { WebSocketClient } from "../../../src/core/websocket-client";
 import { Logger, RoomInfo } from "../../../src/types";
@@ -126,7 +130,7 @@ describe("AgentRoomManager", () => {
       const cachedAgents: AgentRoomInfo[] = [{ agent_id: "agent-1", agent_name: "Agent 1" }];
       manager.cacheRoomAgents("room-123", cachedAgents);
 
-      expect(manager.getRoomAgents("room-123")).toHaveLength(1);
+      expect(manager.getCachedRoomAgents("room-123")).toHaveLength(1);
 
       const addPromise = manager.addAgentToRoom("room-123", "agent-456");
 
@@ -137,7 +141,7 @@ describe("AgentRoomManager", () => {
       await addPromise;
 
       // Cache should be invalidated
-      expect(manager.getRoomAgents("room-123")).toBeUndefined();
+      expect(manager.getCachedRoomAgents("room-123")).toBeUndefined();
     });
   });
 
@@ -205,7 +209,7 @@ describe("AgentRoomManager", () => {
       const cachedAgents: AgentRoomInfo[] = [{ agent_id: "agent-456", agent_name: "Agent 456" }];
       manager.cacheRoomAgents("room-123", cachedAgents);
 
-      expect(manager.getRoomAgents("room-123")).toHaveLength(1);
+      expect(manager.getCachedRoomAgents("room-123")).toHaveLength(1);
 
       const removePromise = manager.removeAgentFromRoom("room-123", "agent-456");
 
@@ -216,7 +220,7 @@ describe("AgentRoomManager", () => {
       await removePromise;
 
       // Cache should be invalidated
-      expect(manager.getRoomAgents("room-123")).toBeUndefined();
+      expect(manager.getCachedRoomAgents("room-123")).toBeUndefined();
     });
   });
 
@@ -374,50 +378,50 @@ describe("AgentRoomManager", () => {
     it("should get room agents from cache", () => {
       manager.cacheRoomAgents("room-123", mockAgents);
 
-      const result = manager.getRoomAgents("room-123");
+      const result = manager.getCachedRoomAgents("room-123");
 
       expect(result).toHaveLength(2);
       expect(result![0].agent_id).toBe("agent-1");
     });
 
     it("should return undefined if room agents not cached", () => {
-      const result = manager.getRoomAgents("room-999");
+      const result = manager.getCachedRoomAgents("room-999");
       expect(result).toBeUndefined();
     });
 
     it("should get available agents from cache", () => {
       manager.cacheAvailableAgents("room-123", mockAgents);
 
-      const result = manager.getAvailableAgents("room-123");
+      const result = manager.getCachedAvailableAgents("room-123");
 
       expect(result).toHaveLength(2);
       expect(result![0].agent_id).toBe("agent-1");
     });
 
     it("should return undefined if available agents not cached", () => {
-      const result = manager.getAvailableAgents("room-999");
+      const result = manager.getCachedAvailableAgents("room-999");
       expect(result).toBeUndefined();
     });
 
     it("should check if agent is in room", () => {
       manager.cacheRoomAgents("room-123", mockAgents);
 
-      expect(manager.isAgentInRoom("room-123", "agent-1")).toBe(true);
-      expect(manager.isAgentInRoom("room-123", "agent-999")).toBe(false);
+      expect(manager.checkAgentInRoom("room-123", "agent-1")).toBe(true);
+      expect(manager.checkAgentInRoom("room-123", "agent-999")).toBe(false);
     });
 
-    it("should return undefined for isAgentInRoom if not cached", () => {
-      expect(manager.isAgentInRoom("room-999", "agent-1")).toBeUndefined();
+    it("should return undefined for checkAgentInRoom if not cached", () => {
+      expect(manager.checkAgentInRoom("room-999", "agent-1")).toBeUndefined();
     });
 
     it("should get room agent count", () => {
       manager.cacheRoomAgents("room-123", mockAgents);
 
-      expect(manager.getRoomAgentCount("room-123")).toBe(2);
+      expect(manager.getCachedRoomAgentCount("room-123")).toBe(2);
     });
 
     it("should return undefined for count if not cached", () => {
-      expect(manager.getRoomAgentCount("room-999")).toBeUndefined();
+      expect(manager.getCachedRoomAgentCount("room-999")).toBeUndefined();
     });
   });
 
@@ -427,7 +431,7 @@ describe("AgentRoomManager", () => {
     it("should cache room agents", () => {
       manager.cacheRoomAgents("room-123", mockAgents);
 
-      const result = manager.getRoomAgents("room-123");
+      const result = manager.getCachedRoomAgents("room-123");
       expect(result).toHaveLength(1);
       expect(result![0].agent_id).toBe("agent-1");
     });
@@ -435,7 +439,7 @@ describe("AgentRoomManager", () => {
     it("should cache available agents", () => {
       manager.cacheAvailableAgents("room-123", mockAgents);
 
-      const result = manager.getAvailableAgents("room-123");
+      const result = manager.getCachedAvailableAgents("room-123");
       expect(result).toHaveLength(1);
     });
 
@@ -446,9 +450,9 @@ describe("AgentRoomManager", () => {
 
       manager.invalidateCache("room-123");
 
-      expect(manager.getRoomAgents("room-123")).toBeUndefined();
-      expect(manager.getAvailableAgents("room-123")).toBeUndefined();
-      expect(manager.getRoomAgents("room-456")).toBeDefined();
+      expect(manager.getCachedRoomAgents("room-123")).toBeUndefined();
+      expect(manager.getCachedAvailableAgents("room-123")).toBeUndefined();
+      expect(manager.getCachedRoomAgents("room-456")).toBeDefined();
     });
 
     it("should clear all caches", () => {
@@ -458,9 +462,9 @@ describe("AgentRoomManager", () => {
 
       manager.clearAllCaches();
 
-      expect(manager.getRoomAgents("room-123")).toBeUndefined();
-      expect(manager.getRoomAgents("room-456")).toBeUndefined();
-      expect(manager.getAvailableAgents("room-123")).toBeUndefined();
+      expect(manager.getCachedRoomAgents("room-123")).toBeUndefined();
+      expect(manager.getCachedRoomAgents("room-456")).toBeUndefined();
+      expect(manager.getCachedAvailableAgents("room-123")).toBeUndefined();
     });
   });
 
@@ -472,12 +476,12 @@ describe("AgentRoomManager", () => {
     it("should handle status updates and invalidate cache", () => {
       manager.cacheRoomAgents("room-123", mockAgents);
 
-      expect(manager.getRoomAgents("room-123")).toBeDefined();
+      expect(manager.getCachedRoomAgents("room-123")).toBeDefined();
 
       manager.handleStatusUpdate("room-123", "agent-1", "offline");
 
       // Cache should be invalidated
-      expect(manager.getRoomAgents("room-123")).toBeUndefined();
+      expect(manager.getCachedRoomAgents("room-123")).toBeUndefined();
     });
 
     it("should not invalidate other room caches on status update", () => {
@@ -486,29 +490,181 @@ describe("AgentRoomManager", () => {
 
       manager.handleStatusUpdate("room-123", "agent-1", "offline");
 
-      expect(manager.getRoomAgents("room-123")).toBeUndefined();
-      expect(manager.getRoomAgents("room-456")).toBeDefined();
+      expect(manager.getCachedRoomAgents("room-123")).toBeUndefined();
+      expect(manager.getCachedRoomAgents("room-456")).toBeDefined();
+    });
+  });
+
+  describe("listAvailableAgents with pagination", () => {
+    const mockAgents: AgentRoomInfo[] = [
+      { agent_id: "agent-3", agent_name: "Agent 3", status: "online" },
+      { agent_id: "agent-4", agent_name: "Agent 4", status: "online" }
+    ];
+
+    it("should send pagination params in the message data", async () => {
+      const listPromise = manager.listAvailableAgents("room-123", {
+        limit: 20,
+        offset: 10,
+        sortBy: "a-z"
+      });
+
+      setTimeout(() => {
+        manager.emit("agent_room:available_agents_listed", mockAgents, {
+          total: 100,
+          offset: 10,
+          limit: 20,
+          hasMore: true
+        });
+      }, 10);
+
+      await listPromise;
+
+      expect(mockWsClient.sendMessage).toHaveBeenCalledWith({
+        type: "list_available_agents",
+        data: {
+          room_id: "room-123",
+          limit: 20,
+          offset: 10,
+          sort_by: "a-z"
+        }
+      });
+    });
+
+    it("should return PaginatedAgentsResult when called with options", async () => {
+      const listPromise = manager.listAvailableAgents("room-123", {
+        limit: 20,
+        offset: 10
+      });
+
+      setTimeout(() => {
+        manager.emit("agent_room:available_agents_listed", mockAgents, {
+          total: 100,
+          offset: 10,
+          limit: 20,
+          hasMore: true
+        });
+      }, 10);
+
+      const result = await listPromise;
+
+      expect(result).toEqual({
+        agents: mockAgents,
+        total: 100,
+        offset: 10,
+        limit: 20,
+        hasMore: true
+      } satisfies PaginatedAgentsResult);
+    });
+
+    it("should not use cache when called with options object", async () => {
+      // Pre-populate cache
+      manager.cacheAvailableAgents("room-123", mockAgents);
+
+      // Verify cache has data
+      expect(manager.getCachedAvailableAgents("room-123")).toHaveLength(2);
+
+      const listPromise = manager.listAvailableAgents("room-123", { limit: 10 });
+
+      setTimeout(() => {
+        manager.emit("agent_room:available_agents_listed", mockAgents, {
+          total: 2,
+          offset: 0,
+          limit: 10,
+          hasMore: false
+        });
+      }, 10);
+
+      await listPromise;
+
+      // Should have sent a message to the server despite cache existing
+      expect(mockWsClient.sendMessage).toHaveBeenCalledWith(
+        expect.objectContaining({ type: "list_available_agents" })
+      );
+    });
+
+    it("should send all option fields with correct snake_case mapping", async () => {
+      const listPromise = manager.listAvailableAgents("room-123", {
+        limit: 50,
+        offset: 0,
+        includeDetails: true,
+        minimal: false,
+        sortBy: "requests",
+        includeInRoom: true
+      });
+
+      setTimeout(() => {
+        manager.emit("agent_room:available_agents_listed", mockAgents, {
+          total: 2,
+          offset: 0,
+          limit: 50,
+          hasMore: false
+        });
+      }, 10);
+
+      await listPromise;
+
+      expect(mockWsClient.sendMessage).toHaveBeenCalledWith({
+        type: "list_available_agents",
+        data: {
+          room_id: "room-123",
+          limit: 50,
+          offset: 0,
+          include_details: true,
+          minimal: false,
+          sort_by: "requests",
+          include_in_room: true
+        }
+      });
+    });
+
+    it("should maintain backward compatibility with boolean useCache parameter", async () => {
+      const listPromise = manager.listAvailableAgents("room-123", true);
+
+      // Pre-populate cache is not set, so it will send a message
+      // But if we set cache first and call with true, it should use cache
+      manager.cacheAvailableAgents("room-123", mockAgents);
+
+      const cachedResult = await manager.listAvailableAgents("room-123", true);
+
+      // Should return AgentRoomInfo[] (not PaginatedAgentsResult)
+      expect(Array.isArray(cachedResult)).toBe(true);
+      expect(cachedResult).toHaveLength(2);
+      expect((cachedResult as AgentRoomInfo[])[0].agent_id).toBe("agent-3");
+
+      // The first call (no cache) should have triggered sendMessage
+      setTimeout(() => {
+        manager.emit("agent_room:available_agents_listed", mockAgents);
+      }, 10);
+
+      const result = await listPromise;
+
+      // Legacy call returns AgentRoomInfo[], not PaginatedAgentsResult
+      expect(Array.isArray(result)).toBe(true);
+      expect(result as AgentRoomInfo[]).toHaveLength(2);
+      // Should NOT have 'total', 'offset', 'limit', 'hasMore' properties
+      expect(result).not.toHaveProperty("total");
+      expect(result).not.toHaveProperty("hasMore");
     });
   });
 
   describe("Return Value Immutability", () => {
     const mockAgents: AgentRoomInfo[] = [{ agent_id: "agent-1", agent_name: "Agent 1" }];
 
-    it("should return defensive copies from getRoomAgents", () => {
+    it("should return defensive copies from getCachedRoomAgents", () => {
       manager.cacheRoomAgents("room-123", mockAgents);
 
-      const agents1 = manager.getRoomAgents("room-123");
-      const agents2 = manager.getRoomAgents("room-123");
+      const agents1 = manager.getCachedRoomAgents("room-123");
+      const agents2 = manager.getCachedRoomAgents("room-123");
 
       expect(agents1).not.toBe(agents2);
       expect(agents1![0]).not.toBe(agents2![0]);
     });
 
-    it("should return defensive copies from getAvailableAgents", () => {
+    it("should return defensive copies from getCachedAvailableAgents", () => {
       manager.cacheAvailableAgents("room-123", mockAgents);
 
-      const agents1 = manager.getAvailableAgents("room-123");
-      const agents2 = manager.getAvailableAgents("room-123");
+      const agents1 = manager.getCachedAvailableAgents("room-123");
+      const agents2 = manager.getCachedAvailableAgents("room-123");
 
       expect(agents1).not.toBe(agents2);
       expect(agents1![0]).not.toBe(agents2![0]);

package/tests/unit/sdk-new-methods.test.ts

@@ -0,0 +1,221 @@
+/**
+ * Unit tests for TeneoSDK.setApiKeyPreference() and TeneoSDK.sendTxResult()
+ * Tests message shape, destroyed state, and connection state checks
+ */
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { TeneoSDK } from "../../src/teneo-sdk";
+import { ErrorCode } from "../../src/types/error-codes";
+
+describe("TeneoSDK New Methods", () => {
+  let sdk: TeneoSDK;
+  let sendMessageSpy: ReturnType<typeof vi.fn>;
+  let mockWsClient: { isConnected: boolean; sendMessage: ReturnType<typeof vi.fn> };
+
+  beforeEach(() => {
+    // Create SDK with minimal config
+    sdk = new TeneoSDK({ wsUrl: "wss://test.teneo.example.com" });
+
+    // Replace the internal wsClient with a mock that has a writable isConnected
+    sendMessageSpy = vi.fn().mockResolvedValue(undefined);
+    mockWsClient = {
+      isConnected: true,
+      sendMessage: sendMessageSpy
+    };
+    (sdk as any).wsClient = mockWsClient;
+  });
+
+  describe("setApiKeyPreference", () => {
+    it("should send correct message shape with useCustomKeys=true", async () => {
+      await sdk.setApiKeyPreference(true);
+
+      expect(sendMessageSpy).toHaveBeenCalledWith({
+        type: "set_api_key_preference",
+        data: {
+          use_custom_keys: true
+        }
+      });
+    });
+
+    it("should send correct message shape with useCustomKeys=false", async () => {
+      await sdk.setApiKeyPreference(false);
+
+      expect(sendMessageSpy).toHaveBeenCalledWith({
+        type: "set_api_key_preference",
+        data: {
+          use_custom_keys: false
+        }
+      });
+    });
+
+    it("should throw SDKError when destroyed", async () => {
+      (sdk as any).isDestroyed = true;
+
+      await expect(sdk.setApiKeyPreference(true)).rejects.toThrow("SDK has been destroyed");
+
+      try {
+        await sdk.setApiKeyPreference(true);
+      } catch (error: any) {
+        expect(error.code).toBe(ErrorCode.SDK_DESTROYED);
+      }
+    });
+
+    it("should throw SDKError when not connected", async () => {
+      (sdk as any).wsClient.isConnected = false;
+
+      await expect(sdk.setApiKeyPreference(true)).rejects.toThrow(
+        "Not connected to Teneo Protocol"
+      );
+
+      try {
+        await sdk.setApiKeyPreference(true);
+      } catch (error: any) {
+        expect(error.code).toBe(ErrorCode.NOT_CONNECTED);
+      }
+    });
+
+    it("should not call sendMessage when destroyed", async () => {
+      (sdk as any).isDestroyed = true;
+
+      try {
+        await sdk.setApiKeyPreference(true);
+      } catch {
+        // Expected
+      }
+
+      expect(sendMessageSpy).not.toHaveBeenCalled();
+    });
+
+    it("should not call sendMessage when not connected", async () => {
+      (sdk as any).wsClient.isConnected = false;
+
+      try {
+        await sdk.setApiKeyPreference(false);
+      } catch {
+        // Expected
+      }
+
+      expect(sendMessageSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("sendTxResult", () => {
+    it("should send correct message with confirmed status and txHash", async () => {
+      await sdk.sendTxResult("task-123", "confirmed", "0xabc123");
+
+      expect(sendMessageSpy).toHaveBeenCalledWith({
+        type: "tx_result",
+        data: {
+          task_id: "task-123",
+          status: "confirmed",
+          tx_hash: "0xabc123"
+        }
+      });
+    });
+
+    it("should send correct message with failed status and error", async () => {
+      await sdk.sendTxResult("task-456", "failed", undefined, "Insufficient funds");
+
+      expect(sendMessageSpy).toHaveBeenCalledWith({
+        type: "tx_result",
+        data: {
+          task_id: "task-456",
+          status: "failed",
+          error: "Insufficient funds"
+        }
+      });
+    });
+
+    it("should send correct message with rejected status", async () => {
+      await sdk.sendTxResult("task-789", "rejected");
+
+      expect(sendMessageSpy).toHaveBeenCalledWith({
+        type: "tx_result",
+        data: {
+          task_id: "task-789",
+          status: "rejected"
+        }
+      });
+    });
+
+    it("should not include tx_hash when not provided", async () => {
+      await sdk.sendTxResult("task-100", "rejected");
+
+      const sentMessage = sendMessageSpy.mock.calls[0][0];
+      expect(sentMessage.data).not.toHaveProperty("tx_hash");
+    });
+
+    it("should not include error when not provided", async () => {
+      await sdk.sendTxResult("task-100", "confirmed", "0xhash");
+
+      const sentMessage = sendMessageSpy.mock.calls[0][0];
+      expect(sentMessage.data).not.toHaveProperty("error");
+    });
+
+    it("should include both tx_hash and error when both provided", async () => {
+      await sdk.sendTxResult("task-200", "failed", "0xhash", "Reverted");
+
+      expect(sendMessageSpy).toHaveBeenCalledWith({
+        type: "tx_result",
+        data: {
+          task_id: "task-200",
+          status: "failed",
+          tx_hash: "0xhash",
+          error: "Reverted"
+        }
+      });
+    });
+
+    it("should throw SDKError when destroyed", async () => {
+      (sdk as any).isDestroyed = true;
+
+      await expect(sdk.sendTxResult("task-1", "confirmed", "0xhash")).rejects.toThrow(
+        "SDK has been destroyed"
+      );
+
+      try {
+        await sdk.sendTxResult("task-1", "confirmed", "0xhash");
+      } catch (error: any) {
+        expect(error.code).toBe(ErrorCode.SDK_DESTROYED);
+      }
+    });
+
+    it("should throw SDKError when not connected", async () => {
+      (sdk as any).wsClient.isConnected = false;
+
+      await expect(sdk.sendTxResult("task-1", "confirmed", "0xhash")).rejects.toThrow(
+        "Not connected to Teneo Protocol"
+      );
+
+      try {
+        await sdk.sendTxResult("task-1", "confirmed", "0xhash");
+      } catch (error: any) {
+        expect(error.code).toBe(ErrorCode.NOT_CONNECTED);
+      }
+    });
+
+    it("should not call sendMessage when destroyed", async () => {
+      (sdk as any).isDestroyed = true;
+
+      try {
+        await sdk.sendTxResult("task-1", "confirmed");
+      } catch {
+        // Expected
+      }
+
+      expect(sendMessageSpy).not.toHaveBeenCalled();
+    });
+
+    it("should not call sendMessage when not connected", async () => {
+      (sdk as any).wsClient.isConnected = false;
+
+      try {
+        await sdk.sendTxResult("task-1", "failed", undefined, "err");
+      } catch {
+        // Expected
+      }
+
+      expect(sendMessageSpy).not.toHaveBeenCalled();
+    });
+  });
+});