@teneo-protocol/sdk 1.0.0

package/tests/integration/websocket.test.ts

@@ -0,0 +1,381 @@
+import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from "vitest";
+import WebSocket, { WebSocketServer } from "ws";
+import { TeneoSDK } from "../../src";
+import { SDKConfigBuilder } from "../../src/types";
+import { privateKeyToAccount } from "viem/accounts";
+import { generatePrivateKey } from "viem/accounts";
+
+describe("WebSocket Integration Tests", () => {
+  let server: WebSocketServer;
+  let sdk: TeneoSDK;
+  let serverPort: number;
+  let privateKey: string;
+  let walletAddress: string;
+
+  // Mock server to simulate Teneo WebSocket server
+  beforeAll(() => {
+    serverPort = 8081;
+    privateKey = generatePrivateKey();
+    const account = privateKeyToAccount(privateKey);
+    walletAddress = account.address;
+
+    // Create WebSocket server
+    server = new WebSocketServer({ port: serverPort });
+
+    server.on("connection", (ws) => {
+      const subscribedRooms = new Set<string>();
+
+      ws.on("message", (data) => {
+        const message = JSON.parse(data.toString());
+
+        // Handle different message types
+        switch (message.type) {
+          case "request_challenge":
+            ws.send(
+              JSON.stringify({
+                type: "challenge",
+                data: {
+                  challenge: "test-challenge-" + Date.now(),
+                  timestamp: Date.now()
+                }
+              })
+            );
+            break;
+
+          case "auth":
+            ws.send(
+              JSON.stringify({
+                type: "auth_success",
+                data: {
+                  id: "client-123",
+                  type: "user",
+                  address: message.data.address,
+                  nft_verified: false,
+                  is_whitelisted: true,
+                  rooms: []
+                }
+              })
+            );
+            break;
+
+          case "message":
+            // Echo back as task response
+            ws.send(
+              JSON.stringify({
+                type: "task_response",
+                content: `Response to: ${message.content}`,
+                content_type: "text/plain",
+                from: "test-agent",
+                data: {
+                  task_id: "task-" + Date.now(),
+                  agent_name: "Test Agent",
+                  success: true
+                }
+              })
+            );
+            break;
+
+          case "ping":
+            ws.send(JSON.stringify({ type: "pong" }));
+            break;
+
+          case "subscribe":
+            // Add room to subscribed rooms
+            subscribedRooms.add(message.data.room_id);
+            // Send subscribe response with updated subscriptions list
+            ws.send(
+              JSON.stringify({
+                type: "subscribe",
+                data: {
+                  room_id: message.data.room_id,
+                  success: true,
+                  message: "Subscribed successfully",
+                  subscriptions: Array.from(subscribedRooms)
+                }
+              })
+            );
+            // Also send agents list for the room
+            ws.send(
+              JSON.stringify({
+                type: "agents",
+                from: "system",
+                data: [
+                  {
+                    id: "agent-1",
+                    name: "Test Agent 1",
+                    room: message.data.room_id,
+                    status: "online"
+                  }
+                ]
+              })
+            );
+            break;
+
+          case "unsubscribe":
+            // Remove room from subscribed rooms
+            subscribedRooms.delete(message.data.room_id);
+            // Send unsubscribe response with updated subscriptions list
+            ws.send(
+              JSON.stringify({
+                type: "unsubscribe",
+                data: {
+                  room_id: message.data.room_id,
+                  success: true,
+                  message: "Unsubscribed successfully",
+                  subscriptions: Array.from(subscribedRooms)
+                }
+              })
+            );
+            break;
+        }
+      });
+
+      ws.on("close", () => {
+        // Handle client disconnect
+      });
+    });
+  });
+
+  afterAll(async () => {
+    return new Promise<void>((resolve) => {
+      server.close(() => {
+        resolve();
+      });
+    });
+  });
+
+  beforeEach(() => {
+    const config = new SDKConfigBuilder()
+      .withWebSocketUrl(`ws://localhost:${serverPort}`)
+      .withAuthentication(privateKey)
+      .withReconnection(false) // Disable for tests
+      .withAutoJoinRooms(["test-room"]) // Auto-join test room
+      .build();
+
+    sdk = new TeneoSDK(config);
+  });
+
+  afterEach(async () => {
+    await sdk.disconnect();
+  });
+
+  describe("Connection and Authentication", () => {
+    it("should connect to WebSocket server", async () => {
+      await sdk.connect();
+      const state = sdk.getConnectionState();
+      expect(state.connected).toBe(true);
+    }, 15000);
+
+    it("should authenticate successfully", async () => {
+      const authPromise = new Promise((resolve) => {
+        sdk.on("auth:success", resolve);
+      });
+
+      await sdk.connect();
+      await authPromise;
+
+      const state = sdk.getConnectionState();
+      expect(state.authenticated).toBe(true);
+    }, 15000);
+
+    it("should handle challenge-response authentication flow", async () => {
+      const challengeReceived = new Promise((resolve) => {
+        sdk.on("auth:challenge", resolve);
+      });
+
+      const authSuccess = new Promise((resolve) => {
+        sdk.on("auth:success", resolve);
+      });
+
+      await sdk.connect();
+      await challengeReceived;
+      await authSuccess;
+
+      expect(sdk.getConnectionState().authenticated).toBe(true);
+    }, 15000);
+  });
+
+  describe("Message Exchange", () => {
+    beforeEach(async () => {
+      const authPromise = new Promise((resolve) => {
+        sdk.on("auth:success", resolve);
+      });
+      await sdk.connect();
+      await authPromise;
+    });
+
+    it("should send message and receive response", async () => {
+      const responsePromise = new Promise((resolve) => {
+        sdk.on("agent:response", resolve);
+      });
+
+      await sdk.sendMessage("Hello, test message", { room: "test-room" });
+      const response = await responsePromise;
+
+      expect(response).toBeDefined();
+      expect(response).toHaveProperty("content");
+    }, 15000);
+
+    it.skip("should handle formatted responses", async () => {
+      const response = await sdk.sendMessage("Test message", {
+        room: "test-room",
+        waitForResponse: true
+      });
+      expect(response).toContain("Response to: Test message");
+    }, 15000);
+  });
+
+  describe("Room Management", () => {
+    beforeEach(async () => {
+      const authPromise = new Promise((resolve) => {
+        sdk.on("auth:success", resolve);
+      });
+      await sdk.connect();
+      await authPromise;
+    });
+
+    it.skip("should join room and receive agents list", async () => {
+      const agentsPromise = new Promise((resolve) => {
+        sdk.on("agent:list", resolve);
+      });
+
+      await sdk.subscribeToRoom("test-room");
+      const agents = await agentsPromise;
+
+      expect(agents).toBeDefined();
+      expect(Array.isArray(agents)).toBe(true);
+    }, 15000);
+
+    it("should track subscribed rooms", async () => {
+      const subscribePromise = new Promise((resolve, reject) => {
+        sdk.on("room:subscribed", resolve);
+        sdk.on("error", reject);
+        sdk.on("message:error", reject);
+
+        // Set a timeout
+        setTimeout(() => reject(new Error("Event timeout")), 10000);
+      });
+
+      await sdk.subscribeToRoom("test-room-2"); // Use different room to avoid auto-join conflicts
+      await subscribePromise;
+
+      expect(sdk.getSubscribedRooms()).toContain("test-room-2");
+    }, 15000);
+  });
+
+  describe("Error Handling", () => {
+    it.skip("should handle connection errors", async () => {
+      const badSdk = new TeneoSDK(
+        new SDKConfigBuilder()
+          .withWebSocketUrl("wss://nonexistent.local:443") // Valid URL, will fail to connect
+          .withAuthentication(privateKey)
+          .withReconnection(false)
+          .build()
+      );
+
+      await expect(badSdk.connect()).rejects.toThrow();
+    });
+
+    it("should handle message send when not connected", async () => {
+      await expect(sdk.sendMessage("Test", { room: "test-room" })).rejects.toThrow("Not connected");
+    });
+  });
+
+  describe("Webhook Integration", () => {
+    it("should trigger webhook on message response", async () => {
+      // Configure webhook
+      const webhookSdk = new TeneoSDK(
+        new SDKConfigBuilder()
+          .withWebSocketUrl(`ws://localhost:${serverPort}`)
+          .withAuthentication(privateKey)
+          .withWebhook("http://localhost:3001/webhook")
+          .withReconnection(false)
+          .build()
+      );
+
+      const authPromise = new Promise((resolve) => {
+        webhookSdk.on("auth:success", resolve);
+      });
+
+      await webhookSdk.connect();
+      await authPromise;
+
+      // Webhook would be triggered but we can't test actual HTTP without a server
+      // Just verify the handler is set up
+      expect(webhookSdk).toBeDefined();
+
+      await webhookSdk.disconnect();
+    }, 15000);
+  });
+});
+
+describe("Integration with Real Server", () => {
+  const REAL_SERVER_URL = "wss://dev-rooms-websocket-ai-core-o9fmb.ondigitalocean.app/ws";
+  let sdk: TeneoSDK;
+  let privateKey: string;
+
+  beforeEach(() => {
+    privateKey = generatePrivateKey();
+    const config = new SDKConfigBuilder()
+      .withWebSocketUrl(REAL_SERVER_URL)
+      .withAuthentication(privateKey)
+      .withReconnection(false)
+      .build();
+
+    sdk = new TeneoSDK(config);
+  });
+
+  afterEach(async () => {
+    await sdk.disconnect();
+  });
+
+  // Skip these tests by default - only run when explicitly testing against real server
+  it.skip("should connect to real Teneo server", async () => {
+    await sdk.connect();
+    expect(sdk.getConnectionState().connected).toBe(true);
+  });
+
+  it.skip("should authenticate with real server", async () => {
+    await sdk.connect();
+
+    const authSuccess = new Promise((resolve, reject) => {
+      sdk.on("auth:success", resolve);
+      sdk.on("auth:error", reject);
+      setTimeout(() => reject(new Error("Auth timeout")), 10000);
+    });
+
+    const result = await authSuccess;
+    expect(result).toBeDefined();
+  });
+
+  it.skip("should receive agent list from real server", async () => {
+    await sdk.connect();
+
+    await new Promise((resolve) => {
+      sdk.on("auth:success", resolve);
+    });
+
+    const agents = await sdk.getAgents();
+    expect(Array.isArray(agents)).toBe(true);
+  });
+
+  it.skip("should send message to real coordinator", async () => {
+    await sdk.connect();
+
+    await new Promise((resolve) => {
+      sdk.on("auth:success", resolve);
+    });
+
+    const responsePromise = new Promise((resolve, reject) => {
+      sdk.on("agent:selected", resolve);
+      sdk.on("error", reject);
+      setTimeout(() => reject(new Error("Response timeout")), 15000);
+    });
+
+    await sdk.sendMessage("Hello, can you help me?", { room: "test-room" });
+    const response = await responsePromise;
+
+    expect(response).toBeDefined();
+    expect(response).toHaveProperty("data");
+  });
+});

package/tests/integration-setup.ts

@@ -0,0 +1,16 @@
+import { TextEncoder, TextDecoder } from "util";
+import { config } from "dotenv";
+import { resolve } from "path";
+
+// Load .env.test file for integration tests
+config({ path: resolve(__dirname, "../.env.test") });
+
+// Polyfill TextEncoder/TextDecoder for Node.js environment
+global.TextEncoder = TextEncoder as any;
+global.TextDecoder = TextDecoder as any;
+
+// Set test environment variables
+process.env.NODE_ENV = "test";
+
+// For integration tests, we need REAL timers and REAL console output
+// Do NOT mock console or timers for integration tests

package/tests/setup.ts

@@ -0,0 +1,34 @@
+import { vi, afterEach, afterAll } from "vitest";
+import { TextEncoder, TextDecoder } from "util";
+
+// Polyfill TextEncoder/TextDecoder for Node.js environment
+global.TextEncoder = TextEncoder as any;
+global.TextDecoder = TextDecoder as any;
+
+// Mock console methods to reduce test output noise
+global.console = {
+  ...console,
+  log: vi.fn(),
+  debug: vi.fn(),
+  info: vi.fn(),
+  warn: vi.fn(),
+  // Keep error for debugging failed tests
+  error: console.error
+};
+
+// Set test environment variables
+process.env.NODE_ENV = "test";
+
+// Mock timers for testing reconnection logic
+vi.useFakeTimers({ shouldAdvanceTime: true });
+
+// Clean up after each test
+afterEach(() => {
+  vi.clearAllMocks();
+  vi.clearAllTimers();
+});
+
+// Restore real timers after all tests
+afterAll(() => {
+  vi.useRealTimers();
+});

package/tsconfig.json

@@ -0,0 +1,32 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "resolveJsonModule": true,
+    "moduleResolution": "node",
+    "allowSyntheticDefaultImports": true,
+    "noImplicitAny": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,42 @@
+import { defineConfig } from "vitest/config";
+import path from "path";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json", "html", "lcov"],
+      exclude: [
+        "node_modules/**",
+        "dist/**",
+        "examples/**",
+        "**/*.test.ts",
+        "**/*.spec.ts",
+        "**/index.ts",
+        "vitest.config.ts"
+      ],
+      thresholds: {
+        lines: 80,
+        functions: 80,
+        branches: 80,
+        statements: 80
+      }
+    },
+    include: ["src/**/*.test.ts", "src/**/*.spec.ts", "tests/**/*.test.ts", "tests/**/*.spec.ts"],
+    setupFiles: ["./tests/setup.ts"],
+    testTimeout: 10000,
+    hookTimeout: 10000
+  },
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+      "@types": path.resolve(__dirname, "./src/types"),
+      "@core": path.resolve(__dirname, "./src/core"),
+      "@handlers": path.resolve(__dirname, "./src/handlers"),
+      "@formatters": path.resolve(__dirname, "./src/formatters"),
+      "@utils": path.resolve(__dirname, "./src/utils")
+    }
+  }
+});

package/vitest.integration.config.ts

@@ -0,0 +1,23 @@
+import { defineConfig } from "vitest/config";
+import path from "path";
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: "node",
+    include: ["tests/integration/**/*.test.ts"],
+    setupFiles: ["./tests/integration-setup.ts"],
+    testTimeout: 60000,
+    hookTimeout: 60000
+  },
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+      "@types": path.resolve(__dirname, "./src/types"),
+      "@core": path.resolve(__dirname, "./src/core"),
+      "@handlers": path.resolve(__dirname, "./src/handlers"),
+      "@formatters": path.resolve(__dirname, "./src/formatters"),
+      "@utils": path.resolve(__dirname, "./src/utils")
+    }
+  }
+});