@teneo-protocol/sdk 1.0.1 → 2.0.0

package/examples/usage/01-connect.ts

@@ -15,7 +15,7 @@ import { TeneoSDK, SDKConfigBuilder } from "../../dist/index.js";
 
 // Load configuration from environment
 const WS_URL =
-  process.env.WS_URL || "wss://dev-rooms-websocket-ai-core-o9fmb.ondigitalocean.app/ws";
+  process.env.WS_URL || "wss://your-teneo-server.com/ws";
 const PRIVATE_KEY = process.env.PRIVATE_KEY || "";
 const DEFAULT_ROOM = process.env.DEFAULT_ROOM || "general";
 

package/examples/usage/02-list-agents.ts

@@ -15,7 +15,7 @@ import { TeneoSDK, SDKConfigBuilder } from "../../dist/index.js";
 
 // Load configuration from environment
 const WS_URL =
-  process.env.WS_URL || "wss://dev-rooms-websocket-ai-core-o9fmb.ondigitalocean.app/ws";
+  process.env.WS_URL || "wss://your-teneo-server.com/ws";
 const PRIVATE_KEY = process.env.PRIVATE_KEY || "";
 const DEFAULT_ROOM = process.env.DEFAULT_ROOM || "general";
 

package/examples/usage/03-pick-agent.ts

@@ -16,7 +16,7 @@ import { TeneoSDK, SDKConfigBuilder, FormattedResponse } from "../../dist/index.
 
 // Load configuration from environment
 const WS_URL =
-  process.env.WS_URL || "wss://dev-rooms-websocket-ai-core-o9fmb.ondigitalocean.app/ws";
+  process.env.WS_URL || "wss://your-teneo-server.com/ws";
 const PRIVATE_KEY = process.env.PRIVATE_KEY || "";
 const DEFAULT_ROOM = process.env.DEFAULT_ROOM || "general";
 

package/examples/usage/04-find-by-capability.ts

@@ -16,7 +16,7 @@ import { TeneoSDK, SDKConfigBuilder } from "../../dist/index.js";
 
 // Load configuration from environment
 const WS_URL =
-  process.env.WS_URL || "wss://dev-rooms-websocket-ai-core-o9fmb.ondigitalocean.app/ws";
+  process.env.WS_URL || "wss://your-teneo-server.com/ws";
 const PRIVATE_KEY = process.env.PRIVATE_KEY || "";
 const DEFAULT_ROOM = process.env.DEFAULT_ROOM || "general";
 

package/examples/usage/05-webhook-example.ts

@@ -27,7 +27,7 @@ import type { Request, Response } from "express";
 
 // Load configuration from environment
 const WS_URL =
-  process.env.WS_URL || "wss://dev-rooms-websocket-ai-core-o9fmb.ondigitalocean.app/ws";
+  process.env.WS_URL || "wss://your-teneo-server.com/ws";
 const PRIVATE_KEY = process.env.PRIVATE_KEY || "";
 const DEFAULT_ROOM = process.env.DEFAULT_ROOM || "general";
 const WEBHOOK_PORT = parseInt(process.env.WEBHOOK_PORT || "3001");

package/examples/usage/06-simple-api-server.ts

@@ -22,7 +22,7 @@ import { TeneoSDK, SDKConfigBuilder } from "../../dist/index.js";
 
 // Load configuration from environment
 const WS_URL =
-  process.env.WS_URL || "wss://dev-rooms-websocket-ai-core-o9fmb.ondigitalocean.app/ws";
+  process.env.WS_URL || "wss://your-teneo-server.com/ws";
 const PRIVATE_KEY = process.env.PRIVATE_KEY || "";
 const DEFAULT_ROOM = process.env.DEFAULT_ROOM || "general";
 const PORT = parseInt(process.env.PORT || "3000");

package/examples/usage/07-event-listener.ts

@@ -16,7 +16,7 @@ import { TeneoSDK, SDKConfigBuilder } from "../../dist/index.js";
 
 // Load configuration from environment
 const WS_URL =
-  process.env.WS_URL || "wss://dev-rooms-websocket-ai-core-o9fmb.ondigitalocean.app/ws";
+  process.env.WS_URL || "wss://your-teneo-server.com/ws";
 const PRIVATE_KEY = process.env.PRIVATE_KEY || "";
 const DEFAULT_ROOM = process.env.DEFAULT_ROOM || "general";
 

package/examples/usage/README.md

@@ -29,7 +29,7 @@ Create a `.env` file in the project root or export these variables:
 ```bash
 # Required
 PRIVATE_KEY=your_ethereum_private_key_here
-WS_URL=wss://dev-rooms-websocket-ai-core-o9fmb.ondigitalocean.app/ws
+WS_URL=wss://your-teneo-server.com/ws
 
 # Optional
 DEFAULT_ROOM=general

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teneo-protocol/sdk",
-  "version": "1.0.1",
+  "version": "2.0.0",
   "description": "TypeScript SDK for external platforms to interact with Teneo agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,6 +15,14 @@
   ],
   "author": "Teneo Protocol",
   "license": "AGPL-3.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/TeneoProtocolAI/teneo-sdk.git"
+  },
+  "bugs": {
+    "url": "https://github.com/TeneoProtocolAI/teneo-sdk/issues"
+  },
+  "homepage": "https://github.com/TeneoProtocolAI/teneo-sdk#readme",
   "dependencies": {
     "eventemitter3": "^5.0.1",
     "node-fetch": "^3.3.2",

package/src/core/websocket-client.ts

@@ -56,6 +56,8 @@ export class WebSocketClient extends EventEmitter<SDKEvents> {
   private deduplicationCache?: DeduplicationCache;
   private reconnectPolicy: RetryPolicy;
   private roomManager?: any; // Reference to RoomManager for handler context
+  private roomManagementManager?: any; // Reference to RoomManagementManager for handler context (v2.0.0)
+  private agentRoomManager?: any; // Reference to AgentRoomManager for handler context (v2.0.0)
   private intentionalDisconnect: boolean = false; // Track intentional disconnect to prevent reconnection
 
   private connectionState: ConnectionState = {
@@ -211,6 +213,22 @@ export class WebSocketClient extends EventEmitter<SDKEvents> {
     this.roomManager = roomManager;
   }
 
+  /**
+   * Sets the room management manager for room CRUD operations (v2.0.0)
+   * @internal
+   */
+  public setRoomManagementManager(roomManagementManager: any): void {
+    this.roomManagementManager = roomManagementManager;
+  }
+
+  /**
+   * Sets the agent room manager for agent-room operations (v2.0.0)
+   * @internal
+   */
+  public setAgentRoomManager(agentRoomManager: any): void {
+    this.agentRoomManager = agentRoomManager;
+  }
+
   /**
    * Establishes a WebSocket connection to the Teneo server.
    * Handles connection timeout, authentication challenge-response flow,
@@ -296,7 +314,11 @@ export class WebSocketClient extends EventEmitter<SDKEvents> {
           if (parseResult.success) {
             this.handleMessage(parseResult.data as BaseMessage);
           } else {
-            this.logger.error("Invalid message format", parseResult.error);
+            // Use warn instead of error - allows SDK to be more resilient
+            this.logger.warn("Received message with unknown or invalid format", {
+              type: rawMessage?.type,
+              error: parseResult.error?.message
+            });
             this.emit(
               "message:error",
               new ValidationError("Invalid message format", parseResult.error),
@@ -494,7 +516,7 @@ export class WebSocketClient extends EventEmitter<SDKEvents> {
           this.logger.error("Failed to send message", error);
           reject(error);
         } else {
-          this.logger.debug("Message sent", { type: validatedMessage.type });
+          this.logger.debug("Message sent", validatedMessage);
           this.emit("message:sent", validatedMessage);
           resolve();
         }
@@ -653,6 +675,8 @@ export class WebSocketClient extends EventEmitter<SDKEvents> {
       updateConnectionState: (update: any) => this.updateConnectionState(update),
       updateAuthState: (update: any) => this.updateAuthState(update),
       roomManager: this.roomManager,
+      roomManagementManager: this.roomManagementManager,
+      agentRoomManager: this.agentRoomManager,
       account: this.account,
       sendMessage: (message: BaseMessage) => this.sendMessage(message)
     };

package/src/handlers/message-handlers/agent-room-operation-response-handler.ts

@@ -0,0 +1,83 @@
+/**
+ * Handler for agent_room_operation_response messages (v2.0.0)
+ * Processes responses from agent-room operations (add, remove)
+ */
+
+import {
+  AgentRoomOperationResponse,
+  AgentRoomOperationResponseSchema
+} from "../../types";
+import { BaseMessageHandler } from "./base-handler";
+import { HandlerContext } from "./types";
+import { SDKError } from "../../types/events";
+import { ErrorCode } from "../../types/error-codes";
+
+export class AgentRoomOperationResponseHandler extends BaseMessageHandler<AgentRoomOperationResponse> {
+  readonly type = "agent_room_operation_response" as const;
+  readonly schema = AgentRoomOperationResponseSchema;
+
+  protected handleValidated(
+    message: AgentRoomOperationResponse,
+    context: HandlerContext
+  ): void {
+    const { success, message: errorMessage, room_id, agent_id } = message.data;
+
+    context.logger.debug("Handling agent_room_operation_response", {
+      success,
+      roomId: room_id,
+      agentId: agent_id
+    });
+
+    if (!success) {
+      // Operation failed - emit error events
+      const error = new SDKError(
+        errorMessage || "Agent room operation failed",
+        ErrorCode.OPERATION_FAILED
+      );
+
+      context.logger.error("Agent room operation failed", {
+        roomId: room_id,
+        agentId: agent_id,
+        error: errorMessage
+      });
+
+      // Emit both add and remove error events - listeners will filter by room/agent ID
+      this.emit(context, "agent_room:add_error", error, room_id);
+      this.emit(context, "agent_room:remove_error", error, room_id);
+
+      // Send webhook
+      this.sendWebhook(context, "agent_room_operation_error", {
+        success: false,
+        message: errorMessage,
+        room_id,
+        agent_id
+      });
+
+      return;
+    }
+
+    // Operation succeeded
+    if (room_id && agent_id) {
+      context.logger.info("Agent room operation succeeded", {
+        roomId: room_id,
+        agentId: agent_id
+      });
+
+      // Emit success events
+      // The promise handlers in AgentRoomManager will filter by room_id and agent_id
+      this.emit(context, "agent_room:agent_added", room_id, agent_id);
+      this.emit(context, "agent_room:agent_removed", room_id, agent_id);
+
+      // Send webhook
+      this.sendWebhook(context, "agent_room_operation", {
+        success: true,
+        room_id,
+        agent_id,
+        message: "Agent room operation completed successfully"
+      });
+    } else {
+      // Unexpected: success but missing required fields
+      context.logger.warn("Agent room operation succeeded but missing room_id or agent_id");
+    }
+  }
+}

package/src/handlers/message-handlers/agent-status-update-handler.ts

@@ -0,0 +1,58 @@
+/**
+ * Handler for agent_status_update messages (v2.0.0)
+ * Processes real-time agent status updates for rooms
+ */
+
+import {
+  AgentStatusUpdateMessage,
+  AgentStatusUpdateMessageSchema
+} from "../../types";
+import { BaseMessageHandler } from "./base-handler";
+import { HandlerContext } from "./types";
+
+export class AgentStatusUpdateHandler extends BaseMessageHandler<AgentStatusUpdateMessage> {
+  readonly type = "agent_status_update" as const;
+  readonly schema = AgentStatusUpdateMessageSchema;
+
+  protected handleValidated(
+    message: AgentStatusUpdateMessage,
+    context: HandlerContext
+  ): void {
+    const { room_id, agent_id, status, agent } = message.data;
+
+    context.logger.debug("Handling agent_status_update", {
+      roomId: room_id,
+      agentId: agent_id,
+      status,
+      hasAgent: !!agent
+    });
+
+    // Invalidate cache for this room via agent room manager
+    const agentRoomManager = (context as any).agentRoomManager;
+    if (agentRoomManager && typeof agentRoomManager.handleStatusUpdate === "function") {
+      agentRoomManager.handleStatusUpdate(room_id, agent_id, status);
+    }
+
+    context.logger.info("Agent status updated", {
+      roomId: room_id,
+      agentId: agent_id,
+      status
+    });
+
+    // Emit status update event
+    this.emit(context, "agent_room:status_update", {
+      roomId: room_id,
+      agentId: agent_id,
+      status,
+      agent
+    });
+
+    // Send webhook
+    this.sendWebhook(context, "agent_status_update", {
+      room_id,
+      agent_id,
+      status,
+      agent
+    });
+  }
+}

package/src/handlers/message-handlers/auth-message-handler.ts

@@ -26,8 +26,27 @@ export class AuthMessageHandler extends BaseMessageHandler<AuthMessage> {
         isCachedAuth ? "Using cached authentication" : "Authentication successful"
       );
 
-      // Extract rooms
-      const rooms = this.extractRooms(message.data?.rooms);
+      // Extract rooms from both 'rooms' (public) and 'private_rooms' (owned private) arrays
+      const publicRooms = this.extractRooms(message.data?.rooms);
+      const privateRooms = this.extractRooms(message.data?.private_rooms);
+
+      // Combine all rooms, ensuring correct ownership flags
+      // Public rooms from 'rooms' array are NOT owned by the user
+      // Private rooms from 'private_rooms' array ARE owned by the user
+      const allRooms = [
+        ...publicRooms.map((r) => ({
+          ...r,
+          is_owner: false, // Explicitly set to false - public rooms are not owned
+          is_public: r.is_public !== undefined ? r.is_public : true // Ensure is_public is set
+        })),
+        ...privateRooms.map((r) => ({
+          ...r,
+          is_owner: true, // Explicitly set to true - private_rooms array means owned
+          is_public: r.is_public !== undefined ? r.is_public : false // Ensure is_public is set
+        }))
+      ];
+
+      const { privateRoomIds, sharedRoomIds } = this.categorizeRooms(allRooms);
 
       // Update connection state
       this.updateConnectionState(context, { authenticated: true });
@@ -40,11 +59,37 @@ export class AuthMessageHandler extends BaseMessageHandler<AuthMessage> {
         isWhitelisted: message.data?.is_whitelisted,
         isAdmin: message.data?.is_admin_whitelisted,
         nftVerified: message.data?.nft_verified,
-        rooms: rooms.map((r) => r.id),
-        roomObjects: rooms,
-        privateRoomId: message.data?.private_room_id
+        rooms: allRooms.map((r) => r.id),
+        roomObjects: allRooms,
+        privateRoomId: message.data?.private_room_id,
+        // v2.0.0: New fields
+        privateRoomIds, // Rooms user owns
+        sharedRoomIds, // Rooms user is member of
+        maxPrivateRooms: message.data?.max_private_rooms // Max rooms user can create
       });
 
+      // Initialize room management manager with room data (v2.0.0)
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const roomMgmt = (context as any).roomManagementManager;
+      if (roomMgmt) {
+        // Set room limit
+        if (message.data?.max_private_rooms) {
+          roomMgmt.setRoomLimit(message.data.max_private_rooms);
+        }
+
+        // Categorize and cache rooms
+        const ownedRooms = allRooms.filter((r) => r.is_owner === true);
+        const sharedRooms = allRooms.filter((r) => r.is_owner === false);
+        roomMgmt.setOwnedRooms(ownedRooms);
+        roomMgmt.setSharedRooms(sharedRooms);
+
+        context.logger.debug("Room management initialized from auth message", {
+          owned: ownedRooms.length,
+          shared: sharedRooms.length,
+          limit: message.data?.max_private_rooms
+        });
+      }
+
       // Get updated auth state
       const authState = context.getAuthState();
 
@@ -63,4 +108,27 @@ export class AuthMessageHandler extends BaseMessageHandler<AuthMessage> {
     }
     return rooms;
   }
+
+  /**
+   * Categorize rooms into owned vs member rooms based on is_owner flag
+   * @param rooms - Array of room info objects
+   * @returns Object with privateRoomIds (owned) and sharedRoomIds (member)
+   */
+  private categorizeRooms(rooms: Room[]): {
+    privateRoomIds: string[];
+    sharedRoomIds: string[];
+  } {
+    const privateRoomIds: string[] = [];
+    const sharedRoomIds: string[] = [];
+
+    for (const room of rooms) {
+      if (room.is_owner) {
+        if (room.id) privateRoomIds.push(room.id);
+      } else {
+        if (room.id) sharedRoomIds.push(room.id);
+      }
+    }
+
+    return { privateRoomIds, sharedRoomIds };
+  }
 }

package/src/handlers/message-handlers/auth-success-handler.ts

@@ -4,7 +4,7 @@
  */
 
 import { z } from "zod";
-import { AuthSuccessMessage, AuthSuccessMessageSchema, Room } from "../../types";
+import { AuthSuccessMessage, AuthSuccessMessageSchema, RoomInfo } from "../../types";
 import { BaseMessageHandler } from "./base-handler";
 import { HandlerContext } from "./types";
 
@@ -18,8 +18,9 @@ export class AuthSuccessHandler extends BaseMessageHandler<AuthSuccessMessage> {
   ): Promise<void> {
     context.logger.info("Authentication successful");
 
-    // Extract rooms
+    // Extract and categorize rooms
     const rooms = this.extractRooms(message.data.rooms);
+    const { privateRoomIds, sharedRoomIds } = this.categorizeRooms(rooms);
 
     // Update connection state
     this.updateConnectionState(context, { authenticated: true });
@@ -32,14 +33,42 @@ export class AuthSuccessHandler extends BaseMessageHandler<AuthSuccessMessage> {
       isWhitelisted: message.data.is_whitelisted,
       isAdmin: message.data.is_admin_whitelisted,
       nftVerified: message.data.nft_verified,
-      rooms: rooms.map((r) => r.id),
-      roomObjects: rooms,
-      privateRoomId: message.data.private_room_id
+
+      // Backward compatibility: deprecated fields
+      rooms: rooms.map((r) => r.id), // All room IDs
+      privateRoomId: message.data.private_room_id, // DEPRECATED: single private room ID
+
+      // v2.0.0: New fields
+      roomObjects: rooms, // Full room objects with is_owner field
+      privateRoomIds, // Rooms user owns
+      sharedRoomIds, // Rooms user is member of
+      maxPrivateRooms: message.data.max_private_rooms // Max rooms user can create
     });
 
     // Get updated auth state
     const authState = context.getAuthState();
 
+    // Initialize room management manager with room data (v2.0.0)
+    const roomMgmt = (context as any).roomManagementManager;
+    if (roomMgmt) {
+      // Set room limit
+      if (message.data.max_private_rooms) {
+        roomMgmt.setRoomLimit(message.data.max_private_rooms);
+      }
+
+      // Categorize and cache rooms
+      const ownedRooms = rooms.filter((r) => r.is_owner);
+      const sharedRooms = rooms.filter((r) => !r.is_owner);
+      roomMgmt.setOwnedRooms(ownedRooms);
+      roomMgmt.setSharedRooms(sharedRooms);
+
+      context.logger.debug("Room management initialized", {
+        owned: ownedRooms.length,
+        shared: sharedRooms.length,
+        limit: message.data.max_private_rooms
+      });
+    }
+
     // Emit events
     this.emit(context, "auth:success", authState);
     this.emit(context, "ready");
@@ -48,10 +77,33 @@ export class AuthSuccessHandler extends BaseMessageHandler<AuthSuccessMessage> {
   /**
    * Extract and normalize rooms from auth data
    */
-  private extractRooms(rooms?: Room[]): Room[] {
+  private extractRooms(rooms?: RoomInfo[] | null): RoomInfo[] {
     if (!rooms || !Array.isArray(rooms)) {
       return [];
     }
     return rooms;
   }
+
+  /**
+   * Categorize rooms into owned vs member rooms based on is_owner flag
+   * @param rooms - Array of room info objects
+   * @returns Object with privateRoomIds (owned) and sharedRoomIds (member)
+   */
+  private categorizeRooms(rooms: RoomInfo[]): {
+    privateRoomIds: string[];
+    sharedRoomIds: string[];
+  } {
+    const privateRoomIds: string[] = [];
+    const sharedRoomIds: string[] = [];
+
+    for (const room of rooms) {
+      if (room.is_owner) {
+        privateRoomIds.push(room.id);
+      } else {
+        sharedRoomIds.push(room.id);
+      }
+    }
+
+    return { privateRoomIds, sharedRoomIds };
+  }
 }

package/src/handlers/message-handlers/index.ts

@@ -22,6 +22,11 @@ export { PingHandler, PongHandler } from "./ping-pong-handler";
 export { SubscribeResponseHandler } from "./subscribe-response-handler";
 export { UnsubscribeResponseHandler } from "./unsubscribe-response-handler";
 export { ListRoomsResponseHandler } from "./list-rooms-response-handler";
+export { RoomOperationResponseHandler } from "./room-operation-response-handler";
+export { AgentRoomOperationResponseHandler } from "./agent-room-operation-response-handler";
+export { ListRoomAgentsHandler } from "./list-room-agents-handler";
+export { ListAvailableAgentsHandler } from "./list-available-agents-handler";
+export { AgentStatusUpdateHandler } from "./agent-status-update-handler";
 
 // Import for convenience function
 import { TaskResponseHandler } from "./task-response-handler";
@@ -38,6 +43,11 @@ import { PingHandler, PongHandler } from "./ping-pong-handler";
 import { SubscribeResponseHandler } from "./subscribe-response-handler";
 import { UnsubscribeResponseHandler } from "./unsubscribe-response-handler";
 import { ListRoomsResponseHandler } from "./list-rooms-response-handler";
+import { RoomOperationResponseHandler } from "./room-operation-response-handler";
+import { AgentRoomOperationResponseHandler } from "./agent-room-operation-response-handler";
+import { ListRoomAgentsHandler } from "./list-room-agents-handler";
+import { ListAvailableAgentsHandler } from "./list-available-agents-handler";
+import { AgentStatusUpdateHandler } from "./agent-status-update-handler";
 import { MessageHandler } from "./types";
 
 /**
@@ -70,6 +80,15 @@ export function getDefaultHandlers(
     new UnsubscribeResponseHandler(),
     new ListRoomsResponseHandler(),
 
+    // Room Management handlers (v2.0.0)
+    new RoomOperationResponseHandler(),
+
+    // Agent Room Management handlers (v2.0.0)
+    new AgentRoomOperationResponseHandler(),
+    new ListRoomAgentsHandler(),
+    new ListAvailableAgentsHandler(),
+    new AgentStatusUpdateHandler(),
+
     // Keepalive handlers
     new PingHandler(),
     new PongHandler()

package/src/handlers/message-handlers/list-available-agents-handler.ts

@@ -0,0 +1,41 @@
+/**
+ * Handler for available_agents_response messages (v2.0.0)
+ * Processes responses from list_available_agents requests
+ */
+
+import { AvailableAgentsResponse, AvailableAgentsResponseSchema } from "../../types";
+import { BaseMessageHandler } from "./base-handler";
+import { HandlerContext } from "./types";
+import { AgentRoomInfo } from "../../managers/agent-room-manager";
+
+export class ListAvailableAgentsHandler extends BaseMessageHandler<AvailableAgentsResponse> {
+  readonly type = "available_agents_response" as const;
+  readonly schema = AvailableAgentsResponseSchema;
+
+  protected handleValidated(message: AvailableAgentsResponse, context: HandlerContext): void {
+    const { agents } = message.data;
+
+    context.logger.debug("Handling available_agents_response", {
+      agentCount: agents?.length || 0
+    });
+
+    // Parse agents array (handle undefined as empty array)
+    const agentList: AgentRoomInfo[] = agents || [];
+
+    context.logger.info("Available agents listed", {
+      count: agentList.length
+    });
+
+    // Note: We don't cache this globally since it's room-specific
+    // The AgentRoomManager will cache it with the room context
+
+    // Emit success event
+    this.emit(context, "agent_room:available_agents_listed", agentList);
+
+    // Send webhook
+    this.sendWebhook(context, "available_agents_listed", {
+      agents: agentList,
+      count: agentList.length
+    });
+  }
+}

package/src/handlers/message-handlers/list-room-agents-handler.ts

@@ -0,0 +1,61 @@
+/**
+ * Handler for room_agents_response messages (v2.0.0)
+ * Processes responses from list_room_agents requests
+ */
+
+import { RoomAgentsResponse, RoomAgentsResponseSchema } from "../../types";
+import { BaseMessageHandler } from "./base-handler";
+import { HandlerContext } from "./types";
+import { SDKError } from "../../types/events";
+import { ErrorCode } from "../../types/error-codes";
+import { AgentRoomInfo } from "../../managers/agent-room-manager";
+
+export class ListRoomAgentsHandler extends BaseMessageHandler<RoomAgentsResponse> {
+  readonly type = "room_agents_response" as const;
+  readonly schema = RoomAgentsResponseSchema;
+
+  protected handleValidated(
+    message: RoomAgentsResponse,
+    context: HandlerContext
+  ): void {
+    const { room_id, agents } = message.data;
+
+    context.logger.debug("Handling room_agents_response", {
+      roomId: room_id,
+      agentCount: agents?.length || 0
+    });
+
+    if (!room_id) {
+      const error = new SDKError(
+        "Room agents response missing room_id",
+        ErrorCode.VALIDATION_ERROR
+      );
+      this.emit(context, "agent_room:list_error", error, undefined);
+      return;
+    }
+
+    // Parse agents array (handle undefined as empty array)
+    const agentList: AgentRoomInfo[] = agents || [];
+
+    context.logger.info("Room agents listed", {
+      roomId: room_id,
+      count: agentList.length
+    });
+
+    // Cache via agent room manager if available
+    const agentRoomManager = (context as any).agentRoomManager;
+    if (agentRoomManager && typeof agentRoomManager.cacheRoomAgents === "function") {
+      agentRoomManager.cacheRoomAgents(room_id, agentList);
+    }
+
+    // Emit success event
+    this.emit(context, "agent_room:agents_listed", room_id, agentList);
+
+    // Send webhook
+    this.sendWebhook(context, "room_agents_listed", {
+      room_id,
+      agents: agentList,
+      count: agentList.length
+    });
+  }
+}