@teneo-protocol/sdk 2.0.0 → 2.2.0

package/examples/nestjs-dashboard/src/teneo/agents.controller.ts

@@ -0,0 +1,54 @@
+import { Controller, Get, Param, HttpException, HttpStatus } from "@nestjs/common";
+import { TeneoService } from "./teneo.service";
+
+@Controller("api/agents")
+export class AgentsController {
+  constructor(private readonly teneoService: TeneoService) {}
+
+  @Get()
+  getAgents() {
+    return this.teneoService.getAgents();
+  }
+
+  @Get("search/capability/:capability")
+  findAgentsByCapability(@Param("capability") capability: string) {
+    try {
+      const agents = this.teneoService.findAgentsByCapability(capability);
+      return {
+        capability,
+        count: agents.length,
+        agents
+      };
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.BAD_REQUEST);
+    }
+  }
+
+  @Get("search/name/:name")
+  findAgentsByName(@Param("name") name: string) {
+    try {
+      const agents = this.teneoService.findAgentsByName(name);
+      return {
+        query: name,
+        count: agents.length,
+        agents
+      };
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.BAD_REQUEST);
+    }
+  }
+
+  @Get("search/status/:status")
+  findAgentsByStatus(@Param("status") status: string) {
+    try {
+      const agents = this.teneoService.findAgentsByStatus(status);
+      return {
+        status,
+        count: agents.length,
+        agents
+      };
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.BAD_REQUEST);
+    }
+  }
+}

package/examples/nestjs-dashboard/src/teneo/events.controller.ts

@@ -0,0 +1,65 @@
+import { Controller, Get, Post, Body, Res } from "@nestjs/common";
+import { Response } from "express";
+import { TeneoService } from "./teneo.service";
+
+@Controller("api")
+export class EventsController {
+  constructor(private readonly teneoService: TeneoService) {}
+
+  @Get("events")
+  getEvents() {
+    return this.teneoService.getRecentEvents();
+  }
+
+  @Get("messages")
+  getMessages() {
+    return this.teneoService.getRecentMessages();
+  }
+
+  @Get("webhooks")
+  getWebhooks() {
+    return this.teneoService.getRecentWebhooks();
+  }
+
+  @Post("webhook")
+  receiveWebhook(@Body() body: any) {
+    this.teneoService.addWebhook(body);
+    return { status: "success", received: true };
+  }
+
+  @Get("sse")
+  sseEndpoint(@Res() res: Response) {
+    res.setHeader("Content-Type", "text/event-stream");
+    res.setHeader("Cache-Control", "no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.flushHeaders();
+
+    this.teneoService.addSSEClient(res);
+
+    // Send initial connection status
+    const connected = this.teneoService.isConnected();
+    const authenticated = this.teneoService.isAuthenticated();
+
+    res.write(
+      `data: ${JSON.stringify({ type: "connection", status: connected ? "connected" : "disconnected" })}\n\n`
+    );
+    res.write(
+      `data: ${JSON.stringify({ type: "auth", status: authenticated ? "success" : "pending" })}\n\n`
+    );
+
+    // Keep-alive ping every 30 seconds
+    const keepAliveInterval = setInterval(() => {
+      try {
+        res.write(": ping\n\n");
+      } catch {
+        clearInterval(keepAliveInterval);
+        this.teneoService.removeSSEClient(res);
+      }
+    }, 30000);
+
+    res.on("close", () => {
+      clearInterval(keepAliveInterval);
+      this.teneoService.removeSSEClient(res);
+    });
+  }
+}

package/examples/nestjs-dashboard/src/teneo/messages.controller.ts

@@ -0,0 +1,47 @@
+import { Controller, Post, Body, HttpException, HttpStatus } from "@nestjs/common";
+import { TeneoService } from "./teneo.service";
+
+@Controller("api/messages")
+export class MessagesController {
+  constructor(private readonly teneoService: TeneoService) {}
+
+  @Post()
+  async sendMessage(@Body() body: { content: string; room: string; waitForResponse?: boolean }) {
+    if (!body.content || typeof body.content !== "string") {
+      throw new HttpException("Content is required", HttpStatus.BAD_REQUEST);
+    }
+
+    if (!body.room || typeof body.room !== "string") {
+      throw new HttpException("Room is required", HttpStatus.BAD_REQUEST);
+    }
+
+    try {
+      const response = await this.teneoService.sendMessage(
+        body.content,
+        body.room,
+        body.waitForResponse || false
+      );
+
+      return {
+        success: true,
+        response: response || null
+      };
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+
+  @Post("direct-command")
+  async sendDirectCommand(@Body() body: { agent: string; command: string; room?: string }) {
+    if (!body.agent || !body.command) {
+      throw new HttpException("Agent and command are required", HttpStatus.BAD_REQUEST);
+    }
+
+    try {
+      await this.teneoService.sendDirectCommand(body.agent, body.command, body.room);
+      return { success: true };
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+}

package/examples/nestjs-dashboard/src/teneo/rooms.controller.ts

@@ -0,0 +1,258 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Put,
+  Delete,
+  Body,
+  Param,
+  Query,
+  HttpException,
+  HttpStatus
+} from "@nestjs/common";
+import { TeneoService } from "./teneo.service";
+
+@Controller("api/rooms")
+export class RoomsController {
+  constructor(private readonly teneoService: TeneoService) {}
+
+  @Get()
+  getRooms() {
+    return this.teneoService.getRooms();
+  }
+
+  @Get("list")
+  async listRooms() {
+    try {
+      return await this.teneoService.listRooms();
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+
+  @Get("available")
+  getAvailableRooms() {
+    const subscribedRooms = this.teneoService.getSubscribedRooms();
+    const ownedRooms = this.teneoService.getOwnedRooms();
+    const sharedRooms = this.teneoService.getSharedRooms();
+
+    const availableRooms: Array<{
+      id: string;
+      name: string;
+      type: string;
+      description?: string;
+    }> = [];
+
+    if (subscribedRooms?.length > 0) {
+      subscribedRooms.forEach((roomId: string) => {
+        availableRooms.push({
+          id: roomId,
+          name: roomId,
+          type: "subscribed"
+        });
+      });
+    }
+
+    if (ownedRooms?.length > 0) {
+      ownedRooms.forEach((room) => {
+        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
+          });
+        }
+      });
+    }
+
+    if (sharedRooms?.length > 0) {
+      sharedRooms.forEach((room) => {
+        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
+          });
+        }
+      });
+    }
+
+    return availableRooms;
+  }
+
+  @Post("join")
+  async joinRoom(@Body() body: { roomId: string }) {
+    if (!body.roomId) {
+      throw new HttpException("Room ID is required", HttpStatus.BAD_REQUEST);
+    }
+
+    try {
+      await this.teneoService.subscribeToRoom(body.roomId);
+      return { success: true };
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+
+  @Post("leave")
+  async leaveRoom(@Body() body: { roomId: string }) {
+    if (!body.roomId) {
+      throw new HttpException("Room ID is required", HttpStatus.BAD_REQUEST);
+    }
+
+    try {
+      await this.teneoService.unsubscribeFromRoom(body.roomId);
+      return { success: true };
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+
+  @Get("owned")
+  getOwnedRooms() {
+    return this.teneoService.getOwnedRooms();
+  }
+
+  @Get("shared")
+  getSharedRooms() {
+    return this.teneoService.getSharedRooms();
+  }
+
+  @Get("limit")
+  getRoomLimit() {
+    return {
+      limit: this.teneoService.getRoomLimit(),
+      count: this.teneoService.getOwnedRoomCount(),
+      canCreate: this.teneoService.canCreateRoom()
+    };
+  }
+
+  @Post()
+  async createRoom(@Body() body: { name: string; description?: string }) {
+    if (!body.name) {
+      throw new HttpException("Room name is required", HttpStatus.BAD_REQUEST);
+    }
+
+    try {
+      return await this.teneoService.createRoom(body.name, body.description);
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+
+  @Put(":id")
+  async updateRoom(@Param("id") id: string, @Body() body: { name?: string; description?: string }) {
+    if (!body.name && !body.description) {
+      throw new HttpException(
+        "At least one field (name or description) must be provided",
+        HttpStatus.BAD_REQUEST
+      );
+    }
+
+    try {
+      return await this.teneoService.updateRoom(id, body);
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+
+  @Delete(":id")
+  async deleteRoom(@Param("id") id: string) {
+    try {
+      await this.teneoService.deleteRoom(id);
+      return { success: true, message: "Room deleted successfully" };
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+
+  @Get(":id/agents")
+  async listRoomAgents(@Param("id") id: string, @Query("cache") cache?: string) {
+    try {
+      const useCache = cache !== "false";
+      const agents = await this.teneoService.listRoomAgents(id, useCache);
+      return {
+        roomId: id,
+        agents,
+        cached: useCache,
+        count: agents.length
+      };
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+
+  @Get(":id/available-agents")
+  async listAvailableAgents(@Param("id") id: string, @Query("cache") cache?: string) {
+    try {
+      const useCache = cache !== "false";
+      const agents = await this.teneoService.listAvailableAgents(id, useCache);
+      return {
+        roomId: id,
+        agents,
+        cached: useCache,
+        count: agents.length
+      };
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+
+  @Post(":roomId/agents/:agentId")
+  async addAgentToRoom(@Param("roomId") roomId: string, @Param("agentId") agentId: string) {
+    try {
+      await this.teneoService.addAgentToRoom(roomId, agentId);
+      return {
+        success: true,
+        message: `Agent ${agentId} added to room ${roomId}`
+      };
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+
+  @Delete(":roomId/agents/:agentId")
+  async removeAgentFromRoom(@Param("roomId") roomId: string, @Param("agentId") agentId: string) {
+    try {
+      await this.teneoService.removeAgentFromRoom(roomId, agentId);
+      return {
+        success: true,
+        message: `Agent ${agentId} removed from room ${roomId}`
+      };
+    } catch (error) {
+      throw new HttpException(error.message, HttpStatus.INTERNAL_SERVER_ERROR);
+    }
+  }
+
+  @Get(":roomId/agents/:agentId/check")
+  checkAgentInRoom(@Param("roomId") roomId: string, @Param("agentId") agentId: string) {
+    const isInRoom = this.teneoService.isAgentInRoom(roomId, agentId);
+    return {
+      roomId,
+      agentId,
+      inRoom: isInRoom,
+      cached: true
+    };
+  }
+
+  @Get(":id/agents/count")
+  getRoomAgentCount(@Param("id") id: string) {
+    const count = this.teneoService.getRoomAgentCount(id);
+    return {
+      roomId: id,
+      count,
+      cached: true
+    };
+  }
+
+  @Post(":id/cache/invalidate")
+  invalidateCache(@Param("id") id: string) {
+    this.teneoService.invalidateAgentRoomCache(id);
+    return {
+      success: true,
+      message: `Cache invalidated for room ${id}`
+    };
+  }
+}

package/examples/nestjs-dashboard/src/teneo/teneo.module.ts

@@ -0,0 +1,13 @@
+import { Module } from "@nestjs/common";
+import { TeneoService } from "./teneo.service";
+import { MessagesController } from "./messages.controller";
+import { RoomsController } from "./rooms.controller";
+import { AgentsController } from "./agents.controller";
+import { EventsController } from "./events.controller";
+
+@Module({
+  providers: [TeneoService],
+  controllers: [MessagesController, RoomsController, AgentsController, EventsController],
+  exports: [TeneoService]
+})
+export class TeneoModule {}