@teneo-protocol/sdk 2.0.0 → 2.2.0

package/tests/payment-flow-test.ts

@@ -0,0 +1,147 @@
+/**
+ * Payment Flow Test - Tests the quote-approve payment flow
+ *
+ * Setup:
+ *   Create a .env file in the teneo-sdk root with:
+ *     PRIVATE_KEY=your_private_key_here
+ *     WS_URL=wss://backend.developer.chatroom.teneo-protocol.ai/ws  # optional
+ *
+ * Run:
+ *   npx tsx tests/payment-flow-test.ts
+ */
+
+import "dotenv/config";
+import { TeneoSDK } from "../src/teneo-sdk";
+
+// Configuration from environment variables (loaded from .env)
+const WS_URL = process.env.WS_URL || "wss://backend.developer.chatroom.teneo-protocol.ai/ws";
+const PRIVATE_KEY = process.env.PRIVATE_KEY;
+
+if (!PRIVATE_KEY) {
+  console.error("❌ Missing PRIVATE_KEY");
+  console.error("");
+  console.error("Setup: Create a .env file in the teneo-sdk root with:");
+  console.error("  PRIVATE_KEY=your_private_key_here");
+  console.error("");
+  console.error("Then run:");
+  console.error("  npx tsx tests/payment-flow-test.ts");
+  process.exit(1);
+}
+
+// Type assertion after validation
+const privateKey: string = PRIVATE_KEY;
+
+let TEST_ROOM = ""; // Will be set after auth to use user's private room
+
+async function testPaymentFlow() {
+  console.log("=== Payment Flow Test ===\n");
+  console.log("WebSocket URL:", WS_URL);
+
+  // Create SDK with quote-approve enabled
+  const config = TeneoSDK.builder()
+    .withWebSocketUrl(WS_URL)
+    .withAuthentication(privateKey)
+    .withPayments({
+      autoApprove: true,
+      maxPricePerRequest: 10_000_000 // Max 10 USDC
+    })
+    .withLogging("info")
+    .build();
+
+  const sdk = new TeneoSDK(config);
+
+  // Set up event listeners
+  sdk.on("connection:open", () => console.log("✓ Connected"));
+  sdk.on("auth:success", (state) => {
+    console.log("✓ Authenticated as:", state.walletAddress);
+    // Get user's first private room
+    if (state.privateRoomIds && state.privateRoomIds.length > 0) {
+      TEST_ROOM = state.privateRoomIds[0];
+      console.log("✓ Using room:", TEST_ROOM);
+    } else if (state.rooms && state.rooms.length > 0) {
+      TEST_ROOM = state.rooms[0];
+      console.log("✓ Using room:", TEST_ROOM);
+    }
+  });
+  sdk.on("quote:received", (quote) => {
+    console.log("\n📋 Quote Received:");
+    console.log("  Task ID:", quote.data.task_id);
+    console.log("  Agent:", quote.data.agent_name);
+    console.log("  Price:", quote.data.pricing.pricePerUnit, "USDC");
+    console.log("  Expires:", quote.data.expires_at);
+  });
+  sdk.on("payment:attached", (data) => {
+    console.log("\n💰 Payment Attached:");
+    console.log("  Agent:", data.agentId);
+    console.log("  Amount:", data.amount / 1_000_000, "USDC");
+    console.log("  Command:", data.command);
+  });
+  sdk.on("agent:response", (response) => {
+    console.log("\n📥 Agent Response:");
+    console.log("  Success:", response.success);
+    console.log("  Content:", response.content.substring(0, 200) + "...");
+  });
+  sdk.on("error", (error) => console.error("❌ Error:", error.message));
+
+  try {
+    // Connect
+    console.log("\nConnecting to", WS_URL);
+    await sdk.connect();
+    console.log("Connected!\n");
+
+    // Wait for auth to complete and room to be set
+    await sleep(500);
+
+    if (!TEST_ROOM) {
+      throw new Error("No room available - auth may have failed");
+    }
+
+    // Subscribe to test room
+    console.log("Subscribing to room:", TEST_ROOM);
+    try {
+      await sdk.subscribeToRoom(TEST_ROOM);
+      console.log("Subscribed!\n");
+    } catch {
+      console.log("Room subscription skipped (private room)\n");
+    }
+
+    // Wait a bit for connection to stabilize
+    await sleep(1000);
+
+    // Send test message - this will trigger quote-approve flow
+    console.log("\n=== Sending Test Request ===");
+    console.log('Request: "get me 1 post from @elonmusk from x"\n');
+
+    const response = await sdk.sendMessage("get me 1 post from @elonmusk from x", {
+      room: TEST_ROOM,
+      waitForResponse: true,
+      timeout: 120000 // 2 minutes
+    });
+
+    if (response) {
+      console.log("\n=== Test Complete ===");
+      console.log("Response received successfully!");
+      console.log(
+        "Humanized:",
+        typeof response.humanized === "string" ? response.humanized.substring(0, 500) : response
+      );
+    }
+  } catch (error: unknown) {
+    const err = error as Error & { details?: unknown };
+    console.error("\n❌ Test failed:", err.message);
+    if (err.details) {
+      console.error("Details:", err.details);
+    }
+  } finally {
+    console.log("\nDisconnecting...");
+    sdk.destroy();
+    console.log("Done!");
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// Run the test
+testPaymentFlow().catch(console.error);

package/tests/unit/handlers/agent-room-operation-response-handler.test.ts

@@ -135,7 +135,11 @@ describe("AgentRoomOperationResponseHandler", () => {
       expect(mockLogger.warn).toHaveBeenCalledWith(
         "Agent room operation succeeded but missing room_id or agent_id"
       );
-      expect(emitSpy).not.toHaveBeenCalledWith("agent_room:agent_added", expect.anything(), expect.anything());
+      expect(emitSpy).not.toHaveBeenCalledWith(
+        "agent_room:agent_added",
+        expect.anything(),
+        expect.anything()
+      );
     });
 
     it("should handle success without room_id", async () => {
@@ -153,7 +157,11 @@ describe("AgentRoomOperationResponseHandler", () => {
       expect(mockLogger.warn).toHaveBeenCalledWith(
         "Agent room operation succeeded but missing room_id or agent_id"
       );
-      expect(emitSpy).not.toHaveBeenCalledWith("agent_room:agent_added", expect.anything(), expect.anything());
+      expect(emitSpy).not.toHaveBeenCalledWith(
+        "agent_room:agent_added",
+        expect.anything(),
+        expect.anything()
+      );
     });
   });
 
@@ -176,21 +184,11 @@ describe("AgentRoomOperationResponseHandler", () => {
       await handler.handle(message, mockContext);
 
       // Should emit both add and remove error events
-      expect(emitSpy).toHaveBeenCalledWith(
-        "agent_room:add_error",
-        expect.any(SDKError),
-        roomId
-      );
-      expect(emitSpy).toHaveBeenCalledWith(
-        "agent_room:remove_error",
-        expect.any(SDKError),
-        roomId
-      );
+      expect(emitSpy).toHaveBeenCalledWith("agent_room:add_error", expect.any(SDKError), roomId);
+      expect(emitSpy).toHaveBeenCalledWith("agent_room:remove_error", expect.any(SDKError), roomId);
 
       // Verify error details
-      const addErrorCall = emitSpy.mock.calls.find(
-        (call) => call[0] === "agent_room:add_error"
-      );
+      const addErrorCall = emitSpy.mock.calls.find((call) => call[0] === "agent_room:add_error");
       const error = addErrorCall[1] as SDKError;
       expect(error.message).toBe(errorMessage);
       expect(error.code).toBe(ErrorCode.OPERATION_FAILED);
@@ -230,9 +228,7 @@ describe("AgentRoomOperationResponseHandler", () => {
       await handler.handle(message, mockContext);
 
       // Should use default error message
-      const addErrorCall = emitSpy.mock.calls.find(
-        (call) => call[0] === "agent_room:add_error"
-      );
+      const addErrorCall = emitSpy.mock.calls.find((call) => call[0] === "agent_room:add_error");
       const error = addErrorCall[1] as SDKError;
       expect(error.message).toBe("Agent room operation failed");
     });
@@ -250,11 +246,7 @@ describe("AgentRoomOperationResponseHandler", () => {
       await handler.handle(message, mockContext);
 
       // Should emit error events with undefined room_id
-      expect(emitSpy).toHaveBeenCalledWith(
-        "agent_room:add_error",
-        expect.any(SDKError),
-        undefined
-      );
+      expect(emitSpy).toHaveBeenCalledWith("agent_room:add_error", expect.any(SDKError), undefined);
       expect(emitSpy).toHaveBeenCalledWith(
         "agent_room:remove_error",
         expect.any(SDKError),
@@ -308,7 +300,7 @@ describe("AgentRoomOperationResponseHandler", () => {
   describe("Message Validation", () => {
     it("should handle invalid message structure", async () => {
       const invalidMessage = {
-        type: "agent_room_operation_response",
+        type: "agent_room_operation_response"
         // Missing data field
       } as any;
 
@@ -321,11 +313,7 @@ describe("AgentRoomOperationResponseHandler", () => {
       );
 
       // Should emit message:error event
-      expect(emitSpy).toHaveBeenCalledWith(
-        "message:error",
-        expect.any(Error),
-        invalidMessage
-      );
+      expect(emitSpy).toHaveBeenCalledWith("message:error", expect.any(Error), invalidMessage);
     });
 
     it("should accept valid message with extra fields", async () => {

package/tests/unit/handlers/agent-status-update-handler.test.ts

@@ -247,7 +247,7 @@ describe("AgentStatusUpdateHandler", () => {
   describe("Message Validation", () => {
     it("should handle invalid message structure", async () => {
       const invalidMessage = {
-        type: "agent_status_update",
+        type: "agent_status_update"
         // Missing data field
       } as any;
 
@@ -260,11 +260,7 @@ describe("AgentStatusUpdateHandler", () => {
       );
 
       // Should emit message:error event
-      expect(emitSpy).toHaveBeenCalledWith(
-        "message:error",
-        expect.any(Error),
-        invalidMessage
-      );
+      expect(emitSpy).toHaveBeenCalledWith("message:error", expect.any(Error), invalidMessage);
     });
 
     it("should accept valid message with extra fields", async () => {

package/tests/unit/handlers/auth-success-handler-rooms.test.ts

@@ -542,9 +542,7 @@ describe("AuthSuccessHandler - Room Management", () => {
           id: "client-123",
           type: "user",
           address: "0xabc...",
-          rooms: [
-            { id: "room-1", name: "Room", is_owner: true } as RoomInfo
-          ],
+          rooms: [{ id: "room-1", name: "Room", is_owner: true } as RoomInfo],
           max_private_rooms: 3
         }
       } as AuthSuccessMessage;

package/tests/unit/handlers/list-available-agents-handler.test.ts

@@ -143,12 +143,8 @@ describe("ListAvailableAgentsHandler", () => {
           agent_id: "agent-1",
           agent_name: "Weather Agent",
           description: "Provides weather information",
-          capabilities: [
-            { name: "weather-forecast", description: "Get weather forecasts" }
-          ],
-          commands: [
-            { trigger: "weather", description: "Check weather" }
-          ],
+          capabilities: [{ name: "weather-forecast", description: "Get weather forecasts" }],
+          commands: [{ trigger: "weather", description: "Check weather" }],
           image: "https://example.com/agent.png",
           status: "online"
         }
@@ -192,7 +188,7 @@ describe("ListAvailableAgentsHandler", () => {
   describe("Message Validation", () => {
     it("should handle invalid message structure", async () => {
       const invalidMessage = {
-        type: "available_agents_response",
+        type: "available_agents_response"
         // Missing data field
       } as any;
 
@@ -205,11 +201,7 @@ describe("ListAvailableAgentsHandler", () => {
       );
 
       // Should emit message:error event
-      expect(emitSpy).toHaveBeenCalledWith(
-        "message:error",
-        expect.any(Error),
-        invalidMessage
-      );
+      expect(emitSpy).toHaveBeenCalledWith("message:error", expect.any(Error), invalidMessage);
     });
 
     it("should accept valid message with extra fields", async () => {

package/tests/unit/handlers/list-room-agents-handler.test.ts

@@ -227,7 +227,7 @@ describe("ListRoomAgentsHandler", () => {
   describe("Message Validation", () => {
     it("should handle invalid message structure", async () => {
       const invalidMessage = {
-        type: "room_agents_response",
+        type: "room_agents_response"
         // Missing data field
       } as any;
 
@@ -240,11 +240,7 @@ describe("ListRoomAgentsHandler", () => {
       );
 
       // Should emit message:error event
-      expect(emitSpy).toHaveBeenCalledWith(
-        "message:error",
-        expect.any(Error),
-        invalidMessage
-      );
+      expect(emitSpy).toHaveBeenCalledWith("message:error", expect.any(Error), invalidMessage);
     });
 
     it("should accept valid message with extra fields", async () => {

package/tests/unit/handlers/room-operation-response-handler.test.ts

@@ -240,25 +240,12 @@ describe("RoomOperationResponseHandler", () => {
       await handler.handle(message, mockContext);
 
       // Should emit all error events (since we can't determine operation type)
-      expect(emitSpy).toHaveBeenCalledWith(
-        "room:create_error",
-        expect.any(SDKError)
-      );
-      expect(emitSpy).toHaveBeenCalledWith(
-        "room:update_error",
-        expect.any(SDKError),
-        roomId
-      );
-      expect(emitSpy).toHaveBeenCalledWith(
-        "room:delete_error",
-        expect.any(SDKError),
-        roomId
-      );
+      expect(emitSpy).toHaveBeenCalledWith("room:create_error", expect.any(SDKError));
+      expect(emitSpy).toHaveBeenCalledWith("room:update_error", expect.any(SDKError), roomId);
+      expect(emitSpy).toHaveBeenCalledWith("room:delete_error", expect.any(SDKError), roomId);
 
       // Verify error details
-      const createErrorCall = emitSpy.mock.calls.find(
-        (call) => call[0] === "room:create_error"
-      );
+      const createErrorCall = emitSpy.mock.calls.find((call) => call[0] === "room:create_error");
       const error = createErrorCall[1] as SDKError;
       expect(error.message).toBe(errorMessage);
       expect(error.code).toBe(ErrorCode.OPERATION_FAILED);
@@ -290,9 +277,7 @@ describe("RoomOperationResponseHandler", () => {
       await handler.handle(message, mockContext);
 
       // Should use default error message
-      const createErrorCall = emitSpy.mock.calls.find(
-        (call) => call[0] === "room:create_error"
-      );
+      const createErrorCall = emitSpy.mock.calls.find((call) => call[0] === "room:create_error");
       const error = createErrorCall[1] as SDKError;
       expect(error.message).toBe("Room operation failed");
     });
@@ -310,16 +295,8 @@ describe("RoomOperationResponseHandler", () => {
 
       // Should still emit error events
       expect(emitSpy).toHaveBeenCalledWith("room:create_error", expect.any(SDKError));
-      expect(emitSpy).toHaveBeenCalledWith(
-        "room:update_error",
-        expect.any(SDKError),
-        undefined
-      );
-      expect(emitSpy).toHaveBeenCalledWith(
-        "room:delete_error",
-        expect.any(SDKError),
-        undefined
-      );
+      expect(emitSpy).toHaveBeenCalledWith("room:update_error", expect.any(SDKError), undefined);
+      expect(emitSpy).toHaveBeenCalledWith("room:delete_error", expect.any(SDKError), undefined);
     });
   });
 
@@ -431,7 +408,7 @@ describe("RoomOperationResponseHandler", () => {
   describe("Message Validation", () => {
     it("should handle invalid message structure", async () => {
       const invalidMessage = {
-        type: "room_operation_response",
+        type: "room_operation_response"
         // Missing data field
       } as any;
 
@@ -444,11 +421,7 @@ describe("RoomOperationResponseHandler", () => {
       );
 
       // Should emit message:error event
-      expect(emitSpy).toHaveBeenCalledWith(
-        "message:error",
-        expect.any(Error),
-        invalidMessage
-      );
+      expect(emitSpy).toHaveBeenCalledWith("message:error", expect.any(Error), invalidMessage);
     });
 
     it("should accept valid message with extra fields", async () => {

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

@@ -8,6 +8,7 @@ import { AgentRoomManager, AgentRoomInfo } from "../../../src/managers/agent-roo
 import { RoomManagementManager } from "../../../src/managers/room-management-manager";
 import { WebSocketClient } from "../../../src/core/websocket-client";
 import { Logger, RoomInfo } from "../../../src/types";
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 import { ErrorCode } from "../../../src/types/error-codes";
 
 describe("AgentRoomManager", () => {
@@ -63,7 +64,7 @@ describe("AgentRoomManager", () => {
       mockWsClient.isConnected = false;
 
       await expect(manager.addAgentToRoom("room-123", "agent-456")).rejects.toThrow(
-        "Not connected to Teneo network"
+        "Not connected to Teneo Protocol"
       );
     });
 
@@ -122,9 +123,7 @@ describe("AgentRoomManager", () => {
 
     it("should invalidate cache after adding agent", async () => {
       // Pre-populate cache
-      const cachedAgents: AgentRoomInfo[] = [
-        { agent_id: "agent-1", agent_name: "Agent 1" }
-      ];
+      const cachedAgents: AgentRoomInfo[] = [{ agent_id: "agent-1", agent_name: "Agent 1" }];
       manager.cacheRoomAgents("room-123", cachedAgents);
 
       expect(manager.getRoomAgents("room-123")).toHaveLength(1);
@@ -164,7 +163,7 @@ describe("AgentRoomManager", () => {
       mockWsClient.isConnected = false;
 
       await expect(manager.removeAgentFromRoom("room-123", "agent-456")).rejects.toThrow(
-        "Not connected to Teneo network"
+        "Not connected to Teneo Protocol"
       );
     });
 
@@ -203,9 +202,7 @@ describe("AgentRoomManager", () => {
 
     it("should invalidate cache after removing agent", async () => {
       // Pre-populate cache
-      const cachedAgents: AgentRoomInfo[] = [
-        { agent_id: "agent-456", agent_name: "Agent 456" }
-      ];
+      const cachedAgents: AgentRoomInfo[] = [{ agent_id: "agent-456", agent_name: "Agent 456" }];
       manager.cacheRoomAgents("room-123", cachedAgents);
 
       expect(manager.getRoomAgents("room-123")).toHaveLength(1);
@@ -277,7 +274,7 @@ describe("AgentRoomManager", () => {
       mockWsClient.isConnected = false;
 
       await expect(manager.listRoomAgents("room-123")).rejects.toThrow(
-        "Not connected to Teneo network"
+        "Not connected to Teneo Protocol"
       );
     });
 
@@ -359,7 +356,7 @@ describe("AgentRoomManager", () => {
       mockWsClient.isConnected = false;
 
       await expect(manager.listAvailableAgents("room-123")).rejects.toThrow(
-        "Not connected to Teneo network"
+        "Not connected to Teneo Protocol"
       );
     });
 
@@ -425,9 +422,7 @@ describe("AgentRoomManager", () => {
   });
 
   describe("Cache Management", () => {
-    const mockAgents: AgentRoomInfo[] = [
-      { agent_id: "agent-1", agent_name: "Agent 1" }
-    ];
+    const mockAgents: AgentRoomInfo[] = [{ agent_id: "agent-1", agent_name: "Agent 1" }];
 
     it("should cache room agents", () => {
       manager.cacheRoomAgents("room-123", mockAgents);
@@ -497,9 +492,7 @@ describe("AgentRoomManager", () => {
   });
 
   describe("Return Value Immutability", () => {
-    const mockAgents: AgentRoomInfo[] = [
-      { agent_id: "agent-1", agent_name: "Agent 1" }
-    ];
+    const mockAgents: AgentRoomInfo[] = [{ agent_id: "agent-1", agent_name: "Agent 1" }];
 
     it("should return defensive copies from getRoomAgents", () => {
       manager.cacheRoomAgents("room-123", mockAgents);

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

@@ -74,17 +74,17 @@ describe("RoomManagementManager", () => {
     it("should reject if not connected", async () => {
       mockWsClient.isConnected = false;
 
-      await expect(
-        manager.createRoom({ name: "Test Room" })
-      ).rejects.toThrow("Not connected to Teneo network");
+      await expect(manager.createRoom({ name: "Test Room" })).rejects.toThrow(
+        "Not connected to Teneo Protocol"
+      );
     });
 
     it("should validate room name", async () => {
       await expect(manager.createRoom({ name: "" })).rejects.toThrow("Room name cannot be empty");
 
-      await expect(
-        manager.createRoom({ name: "a".repeat(101) })
-      ).rejects.toThrow("Room name too long");
+      await expect(manager.createRoom({ name: "a".repeat(101) })).rejects.toThrow(
+        "Room name too long"
+      );
     });
 
     it("should validate room description", async () => {
@@ -106,9 +106,7 @@ describe("RoomManagementManager", () => {
         } as RoomInfo
       ]);
 
-      await expect(
-        manager.createRoom({ name: "New Room" })
-      ).rejects.toThrow("Room limit reached");
+      await expect(manager.createRoom({ name: "New Room" })).rejects.toThrow("Room limit reached");
     });
 
     it("should timeout if no response", async () => {
@@ -178,21 +176,19 @@ describe("RoomManagementManager", () => {
     });
 
     it("should reject if user doesn't own room", async () => {
-      await expect(
-        manager.updateRoom("room-999", { name: "New Name" })
-      ).rejects.toThrow("don't own this room");
+      await expect(manager.updateRoom("room-999", { name: "New Name" })).rejects.toThrow(
+        "don't own this room"
+      );
     });
 
     it("should require at least one field", async () => {
-      await expect(manager.updateRoom("room-123", {})).rejects.toThrow(
-        "At least one field"
-      );
+      await expect(manager.updateRoom("room-123", {})).rejects.toThrow("At least one field");
     });
 
     it("should validate updated name", async () => {
-      await expect(
-        manager.updateRoom("room-123", { name: "" })
-      ).rejects.toThrow("Room name cannot be empty");
+      await expect(manager.updateRoom("room-123", { name: "" })).rejects.toThrow(
+        "Room name cannot be empty"
+      );
     });
 
     it("should validate updated description", async () => {
@@ -273,9 +269,7 @@ describe("RoomManagementManager", () => {
     });
 
     it("should get room by ID from owned rooms", () => {
-      manager.setOwnedRooms([
-        { id: "room-1", name: "Owned Room", is_owner: true } as RoomInfo
-      ]);
+      manager.setOwnedRooms([{ id: "room-1", name: "Owned Room", is_owner: true } as RoomInfo]);
 
       const result = manager.getRoomById("room-1");
       expect(result).toBeDefined();
@@ -283,9 +277,7 @@ describe("RoomManagementManager", () => {
     });
 
     it("should get room by ID from shared rooms", () => {
-      manager.setSharedRooms([
-        { id: "room-2", name: "Shared Room", is_owner: false } as RoomInfo
-      ]);
+      manager.setSharedRooms([{ id: "room-2", name: "Shared Room", is_owner: false } as RoomInfo]);
 
       const result = manager.getRoomById("room-2");
       expect(result).toBeDefined();
@@ -382,9 +374,7 @@ describe("RoomManagementManager", () => {
     });
 
     it("should remove room from cache", () => {
-      manager.setOwnedRooms([
-        { id: "room-1", name: "Room 1", is_owner: true } as RoomInfo
-      ]);
+      manager.setOwnedRooms([{ id: "room-1", name: "Room 1", is_owner: true } as RoomInfo]);
 
       expect(manager.getRoomById("room-1")).toBeDefined();
 
@@ -396,12 +386,8 @@ describe("RoomManagementManager", () => {
 
     it("should clear all caches", () => {
       manager.setRoomLimit(5);
-      manager.setOwnedRooms([
-        { id: "room-1", name: "Room 1", is_owner: true } as RoomInfo
-      ]);
-      manager.setSharedRooms([
-        { id: "room-2", name: "Room 2", is_owner: false } as RoomInfo
-      ]);
+      manager.setOwnedRooms([{ id: "room-1", name: "Room 1", is_owner: true } as RoomInfo]);
+      manager.setSharedRooms([{ id: "room-2", name: "Room 2", is_owner: false } as RoomInfo]);
 
       manager.clearCaches();
 
@@ -413,9 +399,7 @@ describe("RoomManagementManager", () => {
 
   describe("Return Value Immutability", () => {
     it("should return defensive copies from getOwnedRooms", () => {
-      manager.setOwnedRooms([
-        { id: "room-1", name: "Room 1", is_owner: true } as RoomInfo
-      ]);
+      manager.setOwnedRooms([{ id: "room-1", name: "Room 1", is_owner: true } as RoomInfo]);
 
       const rooms1 = manager.getOwnedRooms();
       const rooms2 = manager.getOwnedRooms();
@@ -425,9 +409,7 @@ describe("RoomManagementManager", () => {
     });
 
     it("should return defensive copy from getRoomById", () => {
-      manager.setOwnedRooms([
-        { id: "room-1", name: "Room 1", is_owner: true } as RoomInfo
-      ]);
+      manager.setOwnedRooms([{ id: "room-1", name: "Room 1", is_owner: true } as RoomInfo]);
 
       const room1 = manager.getRoomById("room-1");
       const room2 = manager.getRoomById("room-1");

package/tsconfig.json

@@ -1,8 +1,8 @@
 {
   "compilerOptions": {
-    "target": "ES2020",
+    "target": "ES2022",
     "module": "commonjs",
-    "lib": ["ES2020"],
+    "lib": ["ES2022", "DOM"],
     "outDir": "./dist",
     "rootDir": "./src",
     "strict": true,

package/vitest.config.ts

@@ -25,6 +25,7 @@ export default defineConfig({
       }
     },
     include: ["src/**/*.test.ts", "src/**/*.spec.ts", "tests/**/*.test.ts", "tests/**/*.spec.ts"],
+    exclude: ["tests/integration/**"],
     setupFiles: ["./tests/setup.ts"],
     testTimeout: 10000,
     hookTimeout: 10000