@teneo-protocol/sdk 1.0.1 → 2.2.0

package/examples/production-dashboard/server.ts

@@ -16,6 +16,14 @@
  * - Real-time event streaming
  * - Complete error handling
  *
+ * 🆕 V2.0 Features:
+ * - Multi-room management (create, update, delete rooms)
+ * - Room ownership tracking (owned vs shared rooms)
+ * - Room limits and quotas
+ * - Agent-room customization (add/remove agents per room)
+ * - Agent-room caching with 5-minute TTL
+ * - Real-time agent status updates
+ *
  * Run with: bun run server.ts
  */
 
@@ -28,11 +36,9 @@ import { SDKConfigBuilder, TeneoSDK, SecurePrivateKey } from "../../dist/index.j
 
 // Load environment variables
 const PORT = parseInt(process.env.PORT || "3001");
-const WS_URL =
-  process.env.WS_URL || "wss://dev-rooms-websocket-ai-core-o9fmb.ondigitalocean.app/ws";
+const WS_URL = process.env.WS_URL || "wss://your-teneo-server.com/ws";
 const PRIVATE_KEY = process.env.PRIVATE_KEY || "";
 const WALLET_ADDRESS = process.env.WALLET_ADDRESS || "";
-const DEFAULT_ROOM = process.env.DEFAULT_ROOM || "as1LfBarJNzOIpOQJQ7PH";
 const ENABLE_SIG_VERIFICATION = process.env.ENABLE_SIGNATURE_VERIFICATION === "true";
 const TRUSTED_ADDRESSES = process.env.TRUSTED_ADDRESSES?.split(",").filter(Boolean) || [];
 
@@ -75,7 +81,6 @@ async function initializeSDK() {
     const config = new SDKConfigBuilder()
       .withWebSocketUrl(WS_URL)
       .withAuthentication(secureKey, WALLET_ADDRESS) // Pass SecurePrivateKey instead of plain string
-      .withAutoJoinRooms([DEFAULT_ROOM])
       .withReconnection({ enabled: true, delay: 5000, maxAttempts: 10 })
       // REL-3: Configure custom retry strategies for production resilience
       .withReconnectionStrategy({
@@ -125,8 +130,8 @@ async function initializeSDK() {
     // Set up comprehensive event listeners
     setupSDKEventListeners(sdk);
 
-    // Connect to Teneo network
-    console.log("[SDK] Connecting to Teneo network...");
+    // Connect to Teneo Protocol
+    console.log("[SDK] Connecting to Teneo Protocol...");
     await sdk.connect();
     console.log("[SDK] Successfully connected and authenticated!");
 
@@ -257,6 +262,81 @@ function setupSDKEventListeners(sdk: TeneoSDK) {
     broadcastSSE({ type: "room:list", rooms });
   });
 
+  // Room Management events (v2.0.0)
+  sdk.on("room:created", (room) => {
+    addEvent("room:created", { roomId: room.id, name: room.name });
+    broadcastSSE({ type: "room:created", room });
+  });
+
+  sdk.on("room:updated", (room) => {
+    addEvent("room:updated", { roomId: room.id, name: room.name });
+    broadcastSSE({ type: "room:updated", room });
+  });
+
+  sdk.on("room:deleted", (roomId) => {
+    addEvent("room:deleted", { roomId });
+    broadcastSSE({ type: "room:deleted", roomId });
+  });
+
+  sdk.on("room:create_error", (error) => {
+    addEvent("room:create_error", { error: error.message });
+    errorCounter++;
+  });
+
+  sdk.on("room:update_error", (error, roomId) => {
+    addEvent("room:update_error", { error: error.message, roomId });
+    errorCounter++;
+  });
+
+  sdk.on("room:delete_error", (error, roomId) => {
+    addEvent("room:delete_error", { error: error.message, roomId });
+    errorCounter++;
+  });
+
+  // Agent Room Management events (v2.0.0)
+  sdk.on("agent_room:agent_added", (roomId, agentId) => {
+    addEvent("agent_room:agent_added", { roomId, agentId });
+    broadcastSSE({ type: "agent_room:agent_added", roomId, agentId });
+  });
+
+  sdk.on("agent_room:agent_removed", (roomId, agentId) => {
+    addEvent("agent_room:agent_removed", { roomId, agentId });
+    broadcastSSE({ type: "agent_room:agent_removed", roomId, agentId });
+  });
+
+  sdk.on("agent_room:agents_listed", (roomId, agents) => {
+    addEvent("agent_room:agents_listed", { roomId, count: agents.length });
+  });
+
+  sdk.on("agent_room:available_agents_listed", (agents) => {
+    addEvent("agent_room:available_agents_listed", { count: agents.length });
+  });
+
+  sdk.on("agent_room:status_update", (data) => {
+    addEvent("agent_room:status_update", data);
+    broadcastSSE({ type: "agent_room:status_update", data });
+  });
+
+  sdk.on("agent_room:add_error", (error, roomId) => {
+    addEvent("agent_room:add_error", { error: error.message, roomId });
+    errorCounter++;
+  });
+
+  sdk.on("agent_room:remove_error", (error, roomId) => {
+    addEvent("agent_room:remove_error", { error: error.message, roomId });
+    errorCounter++;
+  });
+
+  sdk.on("agent_room:list_error", (error, roomId) => {
+    addEvent("agent_room:list_error", { error: error.message, roomId });
+    errorCounter++;
+  });
+
+  sdk.on("agent_room:list_available_error", (error) => {
+    addEvent("agent_room:list_available_error", { error: error.message });
+    errorCounter++;
+  });
+
   // Webhook events
   sdk.on("webhook:sent", (payload, url) => {
     addEvent("webhook:sent", { event: payload.event, url });
@@ -594,7 +674,7 @@ app.get("/api/rooms", (c) => {
   return c.json(rooms);
 });
 
-// Get available rooms for sending messages (subscribed + private room)
+// Get available rooms for sending messages (subscribed + private room + owned rooms)
 app.get("/api/rooms/available", (c) => {
   if (!sdk) {
     return c.json({ error: "SDK not initialized" }, 503);
@@ -602,6 +682,8 @@ app.get("/api/rooms/available", (c) => {
 
   const authState = sdk.getAuthState();
   const subscribedRooms = sdk.getSubscribedRooms();
+  const ownedRooms = sdk.getOwnedRooms(); // v2.0.0: Include newly created rooms
+  const sharedRooms = sdk.getSharedRooms(); // v2.0.0: Include shared rooms
 
   // Combine all available rooms
   const availableRooms: Array<{
@@ -637,6 +719,36 @@ app.get("/api/rooms/available", (c) => {
     });
   }
 
+  // Add owned rooms (v2.0.0) - includes newly created rooms
+  if (ownedRooms && ownedRooms.length > 0) {
+    ownedRooms.forEach((room) => {
+      // Only add if not already in the list
+      if (!availableRooms.find((r) => r.id === room.id)) {
+        availableRooms.push({
+          id: room.id,
+          name: room.name || room.id,
+          type: room.is_public ? "public" : "private",
+          description: room.description || undefined
+        });
+      }
+    });
+  }
+
+  // Add shared rooms (v2.0.0) - rooms user is a member of
+  if (sharedRooms && sharedRooms.length > 0) {
+    sharedRooms.forEach((room) => {
+      // Only add if not already in the list
+      if (!availableRooms.find((r) => r.id === room.id)) {
+        availableRooms.push({
+          id: room.id,
+          name: room.name || room.id,
+          type: room.is_public ? "public" : "private",
+          description: room.description || undefined
+        });
+      }
+    });
+  }
+
   // Add private room ID if not already included
   if (authState.privateRoomId && !availableRooms.find((r) => r.id === authState.privateRoomId)) {
     availableRooms.push({
@@ -703,6 +815,236 @@ app.post("/api/room/leave", async (c) => {
   }
 });
 
+// ========================================
+// 🆕 V2.0 ROOM MANAGEMENT API
+// ========================================
+
+// Get owned rooms (v2.0)
+app.get("/api/v2/rooms/owned", (c) => {
+  if (!sdk) {
+    return c.json({ error: "SDK not initialized" }, 503);
+  }
+
+  const ownedRooms = sdk.getOwnedRooms();
+  return c.json(ownedRooms);
+});
+
+// Get shared rooms (v2.0)
+app.get("/api/v2/rooms/shared", (c) => {
+  if (!sdk) {
+    return c.json({ error: "SDK not initialized" }, 503);
+  }
+
+  const sharedRooms = sdk.getSharedRooms();
+  return c.json(sharedRooms);
+});
+
+// Get room limit info (v2.0)
+app.get("/api/v2/rooms/limit", (c) => {
+  if (!sdk) {
+    return c.json({ error: "SDK not initialized" }, 503);
+  }
+
+  return c.json({
+    limit: sdk.getRoomLimit(),
+    count: sdk.getOwnedRoomCount(),
+    canCreate: sdk.canCreateRoom()
+  });
+});
+
+// Create room (v2.0)
+app.post("/api/v2/rooms", async (c) => {
+  if (!sdk || !sdk.isConnected) {
+    return c.json({ error: "SDK not connected" }, 503);
+  }
+
+  try {
+    const { name, description } = await c.req.json();
+
+    if (!name) {
+      return c.json({ error: "Room name is required" }, 400);
+    }
+
+    const room = await sdk.createRoom({ name, description });
+    return c.json(room);
+  } catch (error: any) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// Update room (v2.0)
+app.put("/api/v2/rooms/:id", async (c) => {
+  if (!sdk || !sdk.isConnected) {
+    return c.json({ error: "SDK not connected" }, 503);
+  }
+
+  try {
+    const roomId = c.req.param("id");
+    const updates = await c.req.json();
+
+    if (!updates.name && !updates.description) {
+      return c.json({ error: "At least one field (name or description) must be provided" }, 400);
+    }
+
+    const room = await sdk.updateRoom(roomId, updates);
+    return c.json(room);
+  } catch (error: any) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// Delete room (v2.0)
+app.delete("/api/v2/rooms/:id", async (c) => {
+  if (!sdk || !sdk.isConnected) {
+    return c.json({ error: "SDK not connected" }, 503);
+  }
+
+  try {
+    const roomId = c.req.param("id");
+    await sdk.deleteRoom(roomId);
+    return c.json({ success: true, message: "Room deleted successfully" });
+  } catch (error: any) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// ========================================
+// 🆕 V2.0 AGENT ROOM MANAGEMENT API
+// ========================================
+
+// List agents in a room (v2.0)
+app.get("/api/v2/rooms/:id/agents", async (c) => {
+  if (!sdk || !sdk.isConnected) {
+    return c.json({ error: "SDK not connected" }, 503);
+  }
+
+  try {
+    const roomId = c.req.param("id");
+    const useCache = c.req.query("cache") !== "false"; // Default to true
+
+    const agents = await sdk.listRoomAgents(roomId, useCache);
+    return c.json({
+      roomId,
+      agents,
+      cached: useCache,
+      count: agents.length
+    });
+  } catch (error: any) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// List available agents for a room (v2.0)
+app.get("/api/v2/rooms/:id/available-agents", async (c) => {
+  if (!sdk || !sdk.isConnected) {
+    return c.json({ error: "SDK not connected" }, 503);
+  }
+
+  try {
+    const roomId = c.req.param("id");
+    const useCache = c.req.query("cache") !== "false"; // Default to true
+
+    const agents = await sdk.listAvailableAgents(roomId, useCache);
+    return c.json({
+      roomId,
+      agents,
+      cached: useCache,
+      count: agents.length
+    });
+  } catch (error: any) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// Add agent to room (v2.0)
+app.post("/api/v2/rooms/:roomId/agents/:agentId", async (c) => {
+  if (!sdk || !sdk.isConnected) {
+    return c.json({ error: "SDK not connected" }, 503);
+  }
+
+  try {
+    const roomId = c.req.param("roomId");
+    const agentId = c.req.param("agentId");
+
+    await sdk.addAgentToRoom(roomId, agentId);
+    return c.json({
+      success: true,
+      message: `Agent ${agentId} added to room ${roomId}`
+    });
+  } catch (error: any) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// Remove agent from room (v2.0)
+app.delete("/api/v2/rooms/:roomId/agents/:agentId", async (c) => {
+  if (!sdk || !sdk.isConnected) {
+    return c.json({ error: "SDK not connected" }, 503);
+  }
+
+  try {
+    const roomId = c.req.param("roomId");
+    const agentId = c.req.param("agentId");
+
+    await sdk.removeAgentFromRoom(roomId, agentId);
+    return c.json({
+      success: true,
+      message: `Agent ${agentId} removed from room ${roomId}`
+    });
+  } catch (error: any) {
+    return c.json({ error: error.message }, 500);
+  }
+});
+
+// Check if agent is in room - instant cache query (v2.0)
+app.get("/api/v2/rooms/:roomId/agents/:agentId/check", (c) => {
+  if (!sdk) {
+    return c.json({ error: "SDK not initialized" }, 503);
+  }
+
+  const roomId = c.req.param("roomId");
+  const agentId = c.req.param("agentId");
+  const isInRoom = sdk.isAgentInRoom(roomId, agentId);
+
+  return c.json({
+    roomId,
+    agentId,
+    inRoom: isInRoom,
+    cached: true
+  });
+});
+
+// Get room agent count - instant cache query (v2.0)
+app.get("/api/v2/rooms/:id/agents/count", (c) => {
+  if (!sdk) {
+    return c.json({ error: "SDK not initialized" }, 503);
+  }
+
+  const roomId = c.req.param("id");
+  const count = sdk.getRoomAgentCount(roomId);
+
+  return c.json({
+    roomId,
+    count,
+    cached: true
+  });
+});
+
+// Invalidate agent-room cache for a room (v2.0)
+app.post("/api/v2/rooms/:id/cache/invalidate", (c) => {
+  if (!sdk) {
+    return c.json({ error: "SDK not initialized" }, 503);
+  }
+
+  const roomId = c.req.param("id");
+  sdk.invalidateAgentRoomCache(roomId);
+
+  return c.json({
+    success: true,
+    message: `Cache invalidated for room ${roomId}`
+  });
+});
+
 // Get recent events
 app.get("/api/events", (c) => {
   return c.json(recentEvents.slice(0, 50));

package/examples/room-management-example.ts

@@ -0,0 +1,282 @@
+/**
+ * Room Management Example
+ *
+ * Demonstrates how to create, manage, and organize multiple rooms in the Teneo SDK v2.0.
+ *
+ * This example shows:
+ * - Creating rooms with different configurations
+ * - Checking room limits and quotas
+ * - Querying owned vs shared rooms
+ * - Updating room properties
+ * - Deleting rooms
+ * - Handling room events
+ *
+ * Prerequisites:
+ * - Set TENEO_WS_URL environment variable
+ * - Set PRIVATE_KEY environment variable (64 hex characters, no 0x prefix)
+ *
+ * Run:
+ *   npx ts-node examples/room-management-example.ts
+ */
+
+import { TeneoSDK } from "../src";
+import * as dotenv from "dotenv";
+
+dotenv.config();
+
+const wsUrl = process.env.TENEO_WS_URL!;
+const privateKey = process.env.PRIVATE_KEY!;
+
+async function main() {
+  console.log("🚀 Teneo SDK v2.0 - Room Management Example\n");
+
+  // Initialize SDK
+  const sdk = new TeneoSDK({
+    wsUrl,
+    privateKey,
+    logLevel: "info",
+    reconnect: true
+  });
+
+  // Set up event listeners for room operations
+  setupEventListeners(sdk);
+
+  try {
+    // Connect and authenticate
+    console.log("📡 Connecting to Teneo Protocol...");
+    await sdk.connect();
+    console.log("✅ Connected and authenticated\n");
+
+    // Wait a moment for initial room data to load
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+
+    // Step 1: Check current room status
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    console.log("📊 Current Room Status");
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    await displayRoomStatus(sdk);
+
+    // Step 2: Create new rooms
+    console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    console.log("🏗️  Creating New Rooms");
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    const newRooms = await createSampleRooms(sdk);
+
+    // Wait for room creation events to process
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // Step 3: Display updated room status
+    console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    console.log("📊 Updated Room Status");
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    await displayRoomStatus(sdk);
+
+    // Step 4: Update a room
+    if (newRooms.length > 0) {
+      console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+      console.log("📝 Updating Room");
+      console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+      await updateRoomExample(sdk, newRooms[0].id);
+    }
+
+    // Step 5: Query specific room
+    if (newRooms.length > 0) {
+      console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+      console.log("🔍 Querying Specific Room");
+      console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+      const room = sdk.getRoomById(newRooms[0].id);
+      if (room) {
+        console.log(`Room ID: ${room.id}`);
+        console.log(`Name: ${room.name}`);
+        console.log(`Description: ${room.description || "N/A"}`);
+        console.log(`Type: ${room.is_public ? "Public" : "Private"}`);
+        console.log(`Created by: ${room.created_by}`);
+        console.log(`Created at: ${room.created_at}`);
+        console.log(`You are: ${room.is_owner ? "Owner" : "Member"}`);
+      }
+    }
+
+    // Step 6: Delete rooms
+    console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    console.log("🗑️  Cleaning Up (Deleting Rooms)");
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    await deleteRooms(sdk, newRooms);
+
+    // Wait for deletion events to process
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // Step 7: Final room status
+    console.log("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    console.log("📊 Final Room Status");
+    console.log("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━");
+    await displayRoomStatus(sdk);
+
+    console.log("\n✅ Room management example completed!");
+  } catch (error: any) {
+    console.error("\n❌ Error:", error.message);
+    console.error(error.stack);
+  } finally {
+    // Disconnect
+    console.log("\n👋 Disconnecting...");
+    sdk.disconnect();
+    console.log("✅ Disconnected");
+  }
+}
+
+function setupEventListeners(sdk: TeneoSDK) {
+  // Room created
+  sdk.on("room:created", (room) => {
+    console.log(`  ✅ Room created: "${room.name}" (${room.id})`);
+  });
+
+  // Room updated
+  sdk.on("room:updated", (room) => {
+    console.log(`  ✅ Room updated: "${room.name}" (${room.id})`);
+  });
+
+  // Room deleted
+  sdk.on("room:deleted", (roomId) => {
+    console.log(`  ✅ Room deleted: ${roomId}`);
+  });
+
+  // Room errors
+  sdk.on("room:create_error", (error) => {
+    console.error(`  ❌ Failed to create room: ${error.message}`);
+  });
+
+  sdk.on("room:update_error", (error, roomId) => {
+    console.error(`  ❌ Failed to update room ${roomId}: ${error.message}`);
+  });
+
+  sdk.on("room:delete_error", (error, roomId) => {
+    console.error(`  ❌ Failed to delete room ${roomId}: ${error.message}`);
+  });
+}
+
+async function displayRoomStatus(sdk: TeneoSDK) {
+  const ownedRooms = sdk.getOwnedRooms();
+  const sharedRooms = sdk.getSharedRooms();
+  const roomLimit = sdk.getRoomLimit();
+  const roomCount = sdk.getOwnedRoomCount();
+
+  console.log(`Room Capacity: ${roomCount}/${roomLimit} rooms used`);
+  console.log(`Can create more rooms: ${sdk.canCreateRoom() ? "✅ Yes" : "❌ No (limit reached)"}`);
+
+  console.log(`\n📁 Owned Rooms (${ownedRooms.length}):`);
+  if (ownedRooms.length === 0) {
+    console.log("  (none)");
+  } else {
+    ownedRooms.forEach((room, i) => {
+      console.log(`  ${i + 1}. "${room.name}" - ${room.is_public ? "Public" : "Private"}`);
+      console.log(`     ID: ${room.id}`);
+      if (room.description) {
+        console.log(`     Description: ${room.description}`);
+      }
+    });
+  }
+
+  console.log(`\n🤝 Shared Rooms (${sharedRooms.length}):`);
+  if (sharedRooms.length === 0) {
+    console.log("  (none)");
+  } else {
+    sharedRooms.forEach((room, i) => {
+      console.log(`  ${i + 1}. "${room.name}" - ${room.is_public ? "Public" : "Private"}`);
+      console.log(`     ID: ${room.id}`);
+      console.log(`     Created by: ${room.created_by}`);
+    });
+  }
+}
+
+async function createSampleRooms(sdk: TeneoSDK) {
+  const newRooms = [];
+
+  // Check if we can create rooms
+  if (!sdk.canCreateRoom()) {
+    console.log("⚠️  Cannot create rooms - limit reached");
+    console.log(`   Current: ${sdk.getOwnedRoomCount()}/${sdk.getRoomLimit()}`);
+    return newRooms;
+  }
+
+  try {
+    // Create room 1: Private crypto research room
+    console.log("Creating 'Crypto Research' room...");
+    const cryptoRoom = await sdk.createRoom({
+      name: "Crypto Research",
+      description: "Room for cryptocurrency analysis and tracking",
+      isPublic: false
+    });
+    newRooms.push(cryptoRoom);
+
+    // Create room 2: Public gaming room (if we have capacity)
+    if (sdk.canCreateRoom()) {
+      console.log("Creating 'Gaming Hub' room...");
+      const gamingRoom = await sdk.createRoom({
+        name: "Gaming Hub",
+        description: "Public room for gaming-related AI agents",
+        isPublic: true
+      });
+      newRooms.push(gamingRoom);
+    }
+
+    // Create room 3: Research room (if we have capacity)
+    if (sdk.canCreateRoom()) {
+      console.log("Creating 'AI Research' room...");
+      const researchRoom = await sdk.createRoom({
+        name: "AI Research",
+        description: "Room for AI research and experimentation"
+      });
+      newRooms.push(researchRoom);
+    }
+  } catch (error: any) {
+    console.error(`Failed to create room: ${error.message}`);
+  }
+
+  return newRooms;
+}
+
+async function updateRoomExample(sdk: TeneoSDK, roomId: string) {
+  try {
+    const originalRoom = sdk.getRoomById(roomId);
+    if (!originalRoom) {
+      console.log("  ⚠️  Room not found");
+      return;
+    }
+
+    console.log(`Original room name: "${originalRoom.name}"`);
+    console.log(`Original description: "${originalRoom.description || "N/A"}"`);
+
+    console.log("\nUpdating room...");
+    const updatedRoom = await sdk.updateRoom(roomId, {
+      name: `${originalRoom.name} (Updated)`,
+      description: "This room was updated via the SDK v2.0 API"
+    });
+
+    console.log(`\nNew room name: "${updatedRoom.name}"`);
+    console.log(`New description: "${updatedRoom.description}"`);
+  } catch (error: any) {
+    console.error(`Failed to update room: ${error.message}`);
+  }
+}
+
+async function deleteRooms(sdk: TeneoSDK, rooms: any[]) {
+  if (rooms.length === 0) {
+    console.log("No rooms to delete");
+    return;
+  }
+
+  console.log(`Deleting ${rooms.length} room(s)...\n`);
+
+  for (const room of rooms) {
+    try {
+      console.log(`Deleting "${room.name}" (${room.id})...`);
+      await sdk.deleteRoom(room.id);
+      // Wait a bit between deletions
+      await new Promise((resolve) => setTimeout(resolve, 300));
+    } catch (error: any) {
+      console.error(`Failed to delete room ${room.id}: ${error.message}`);
+    }
+  }
+}
+
+// Run the example
+main().catch(console.error);