@teneo-protocol/sdk 1.0.1 → 2.2.0

package/src/utils/bounded-queue.test.ts

@@ -3,7 +3,7 @@
  */
 
 import { describe, it, expect, beforeEach } from "vitest";
-import { BoundedQueue, QueueOverflowError, type OverflowStrategy } from "./bounded-queue";
+import { BoundedQueue, QueueOverflowError } from "./bounded-queue";
 
 describe("BoundedQueue", () => {
   describe("constructor", () => {

package/src/utils/bounded-queue.ts

@@ -181,10 +181,11 @@ export class BoundedQueue<T> {
           `Queue is full (max size: ${this.maxSize}). Cannot add more items.`
         );
 
-      default:
+      default: {
         // TypeScript exhaustiveness check
         const _exhaustive: never = this.strategy;
         throw new Error(`Unknown overflow strategy: ${_exhaustive}`);
+      }
     }
   }
 }

package/src/utils/circuit-breaker.test.ts

@@ -3,7 +3,7 @@
  */
 
 import { describe, it, expect, beforeEach, vi } from "vitest";
-import { CircuitBreaker, CircuitBreakerError, type CircuitState } from "./circuit-breaker";
+import { CircuitBreaker, CircuitBreakerError } from "./circuit-breaker";
 
 describe("CircuitBreaker", () => {
   describe("constructor", () => {

package/src/utils/deduplication-cache.test.ts

@@ -2,7 +2,7 @@
  * Tests for Deduplication Cache
  */
 
-import { describe, it, expect, beforeEach, vi } from "vitest";
+import { describe, it, expect, beforeEach } from "vitest";
 import { DeduplicationCache } from "./deduplication-cache";
 
 describe("DeduplicationCache", () => {

package/src/utils/event-waiter.test.ts

@@ -123,7 +123,7 @@ describe("waitForEvent", () => {
     it("should timeout if no matching event arrives", async () => {
       const promise = waitForEvent(emitter, "filtered:event", {
         timeout: 1000,
-        filter: (data: any) => data.id === 999
+        filter: (data: { id: number }) => data.id === 999
       });
 
       // Emit non-matching events

package/src/utils/event-waiter.ts

@@ -60,7 +60,7 @@ export interface WaitForEventOptions<T> {
  * });
  * ```
  */
-export async function waitForEvent<T = any>(
+export async function waitForEvent<T = unknown>(
   emitter: EventEmitter,
   eventName: string,
   options: WaitForEventOptions<T>
@@ -129,7 +129,7 @@ export async function waitForEvent<T = any>(
  * ]);
  * ```
  */
-export async function waitForAnyEvent<T = any>(
+export async function waitForAnyEvent<T = unknown>(
   waiters: Array<{
     emitter: EventEmitter;
     eventName: string;
@@ -157,7 +157,7 @@ export async function waitForAnyEvent<T = any>(
  * ]);
  * ```
  */
-export async function waitForAllEvents<T = any>(
+export async function waitForAllEvents<T = unknown>(
   waiters: Array<{
     emitter: EventEmitter;
     eventName: string;

package/src/utils/index.ts

@@ -72,3 +72,10 @@ export {
   type RetryStrategy,
   type RetryStrategyType
 } from "./retry-policy";
+
+export {
+  resolveAgentPricing,
+  parseCommandForPricing,
+  type ResolvedPricing,
+  type PriceResolutionOptions
+} from "./pricing-resolver";

package/src/utils/logger.ts

@@ -55,30 +55,30 @@ export function createPinoLogger(level: LogLevel, name?: string): Logger {
 
   // Adapt pino's API to match our Logger interface
   return {
-    debug: (message: string, data?: any) => {
+    debug: (message: string, data?: unknown) => {
       if (data !== undefined) {
-        pinoLogger.debug(data, message);
+        pinoLogger.debug(data as object, message);
       } else {
         pinoLogger.debug(message);
       }
     },
-    info: (message: string, data?: any) => {
+    info: (message: string, data?: unknown) => {
       if (data !== undefined) {
-        pinoLogger.info(data, message);
+        pinoLogger.info(data as object, message);
       } else {
         pinoLogger.info(message);
       }
     },
-    warn: (message: string, data?: any) => {
+    warn: (message: string, data?: unknown) => {
       if (data !== undefined) {
-        pinoLogger.warn(data, message);
+        pinoLogger.warn(data as object, message);
       } else {
         pinoLogger.warn(message);
       }
     },
-    error: (message: string, data?: any) => {
+    error: (message: string, data?: unknown) => {
       if (data !== undefined) {
-        pinoLogger.error(data, message);
+        pinoLogger.error(data as object, message);
       } else {
         pinoLogger.error(message);
       }

package/src/utils/pricing-resolver.ts

@@ -0,0 +1,128 @@
+import { Agent, CommandPricing } from "../types";
+
+const VALID_PRICE_TYPES = ["free", "per-query", "per-item", "time-based-task"] as const;
+type PriceType = (typeof VALID_PRICE_TYPES)[number];
+
+export interface ResolvedPricing {
+  pricePerUnit: number;
+  priceType: PriceType;
+  taskUnit?: string;
+  timeUnit?: "hour" | "day";
+  totalPrice: number;
+  itemCount?: number;
+  duration?: number;
+}
+
+export interface PriceResolutionOptions {
+  commandTrigger?: string;
+  itemCount?: number;
+  duration?: number;
+}
+
+function isValidPriceType(type: string): type is PriceType {
+  return VALID_PRICE_TYPES.includes(type as PriceType);
+}
+
+export function resolveAgentPricing(
+  agent: Agent,
+  options: PriceResolutionOptions = {}
+): ResolvedPricing | null {
+  const { commandTrigger, itemCount = 1, duration = 1 } = options;
+
+  // Validate itemCount and duration are positive
+  if (itemCount < 0 || duration < 0) {
+    return null;
+  }
+
+  let pricing: CommandPricing | undefined;
+
+  if (commandTrigger && agent.commands) {
+    const command = agent.commands.find(
+      (cmd) => cmd.trigger.toLowerCase() === commandTrigger.toLowerCase()
+    );
+    pricing = command?.pricing;
+  }
+
+  if (!pricing) {
+    return null;
+  }
+
+  const rawPriceType = pricing.priceType || "free";
+  const priceType: PriceType = isValidPriceType(rawPriceType) ? rawPriceType : "free";
+  const pricePerUnit = pricing.pricePerUnit || 0;
+
+  // Reject negative prices
+  if (pricePerUnit < 0) {
+    return null;
+  }
+
+  if (priceType === "free" || pricePerUnit === 0) {
+    return {
+      pricePerUnit: 0,
+      priceType: "free",
+      totalPrice: 0
+    };
+  }
+
+  let totalPrice: number;
+
+  switch (priceType) {
+    case "per-query":
+      totalPrice = pricePerUnit;
+      break;
+    case "per-item":
+      totalPrice = pricePerUnit * itemCount;
+      break;
+    case "time-based-task":
+      totalPrice = pricePerUnit * duration;
+      break;
+    default:
+      totalPrice = pricePerUnit;
+  }
+
+  return {
+    pricePerUnit,
+    priceType,
+    taskUnit: pricing.taskUnit,
+    timeUnit: pricing.timeUnit,
+    totalPrice,
+    itemCount: priceType === "per-item" ? itemCount : undefined,
+    duration: priceType === "time-based-task" ? duration : undefined
+  };
+}
+
+export function parseCommandForPricing(content: string): {
+  agentName?: string;
+  commandTrigger?: string;
+  itemCount?: number;
+  duration?: number;
+} {
+  const directCommandMatch = content.match(/^@(\S+)\s+(.+)$/);
+  if (!directCommandMatch) {
+    return {};
+  }
+
+  const agentName = directCommandMatch[1];
+  const commandContent = directCommandMatch[2];
+
+  const parts = commandContent.trim().split(/\s+/);
+  const commandTrigger = parts[0];
+  const args = parts.slice(1);
+
+  let itemCount: number | undefined;
+  let duration: number | undefined;
+
+  for (const arg of args) {
+    const numMatch = arg.match(/^(\d+)$/);
+    if (numMatch) {
+      itemCount = parseInt(numMatch[1], 10);
+    }
+
+    const durationMatch = arg.match(/^(\d+)(h|d)$/i);
+    if (durationMatch) {
+      duration = parseInt(durationMatch[1], 10);
+    }
+  }
+
+  return { agentName, commandTrigger, itemCount, duration };
+}

package/src/utils/rate-limiter.test.ts

@@ -2,7 +2,7 @@
  * Tests for Token Bucket Rate Limiter
  */
 
-import { describe, it, expect, beforeEach, vi } from "vitest";
+import { describe, it, expect } from "vitest";
 import { TokenBucketRateLimiter, RateLimitError } from "./rate-limiter";
 
 describe("TokenBucketRateLimiter", () => {

package/src/utils/rate-limiter.ts

@@ -123,6 +123,7 @@ export class TokenBucketRateLimiter {
   public async consume(timeout?: number): Promise<void> {
     const startTime = Date.now();
 
+    // eslint-disable-next-line no-constant-condition
     while (true) {
       if (this.tryConsume()) {
         return;

package/src/utils/signature-verifier.test.ts

@@ -2,10 +2,10 @@
  * Tests for Signature Verifier
  */
 
-import { describe, it, expect, beforeEach } from "vitest";
+import { describe, it, expect } from "vitest";
 import { privateKeyToAccount } from "viem/accounts";
 import { SignatureVerifier } from "./signature-verifier";
-import { BaseMessage, createUserMessage } from "../types";
+import { BaseMessage } from "../types";
 
 describe("SignatureVerifier", () => {
   // Test accounts

package/src/utils/signature-verifier.ts

@@ -198,10 +198,11 @@ export class SignatureVerifier {
    * @returns Object containing signable fields
    */
   public getSignableContent(message: BaseMessage): object {
-    const { signature, publicKey, id, ...signableContent } = message;
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { signature: _signature, publicKey: _publicKey, id: _id, ...signableContent } = message;
 
     // Include only defined fields for consistent hashing
-    const filtered: Record<string, any> = {};
+    const filtered: Record<string, unknown> = {};
     for (const [key, value] of Object.entries(signableContent)) {
       if (value !== undefined) {
         filtered[key] = value;

package/tests/.env.example

@@ -0,0 +1,7 @@
+# Copy this file to .env in the teneo-sdk root and fill in your values
+
+# Required: Your wallet private key (with 0x prefix)
+PRIVATE_KEY=0x...
+
+# Optional: WebSocket URL (defaults to production)
+# WS_URL=wss://backend.developer.chatroom.teneo-protocol.ai/ws

package/tests/direct-agent-test.ts

@@ -0,0 +1,151 @@
+/**
+ * Direct Agent Test - Tests direct @agent commands with payment
+ *
+ * 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/direct-agent-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/direct-agent-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 testDirectAgentCommand() {
+  console.log("=== Direct Agent Command 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);
+    if (response.content) {
+      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 direct agent command - bypasses coordinator, goes directly to agent
+    console.log("\n=== Sending Direct Agent Command ===");
+    console.log('Command: "@x-agent-enterprise-v2 user @elonmusk"\n');
+
+    const response = await sdk.sendMessage("@x-agent-enterprise-v2 user @elonmusk", {
+      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)
+          : JSON.stringify(response, null, 2).substring(0, 500)
+      );
+    }
+  } 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
+testDirectAgentCommand().catch(console.error);

package/tests/integration/real-server.test.ts

@@ -49,6 +49,7 @@ const hasCredentials = !!(
 describe.skipIf(!hasCredentials)("Real Teneo Server Integration Test", () => {
   let sdk: TeneoSDK;
   let authState: AuthenticationState;
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   let receivedAgents: Agent[] = [];
   let privateRoomId: string = "";
 
@@ -143,6 +144,7 @@ describe.skipIf(!hasCredentials)("Real Teneo Server Integration Test", () => {
 
       let challengeReceived = false;
       let authSuccessReceived = false;
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       let usedCachedAuth = false;
 
       const challengePromise = new Promise<string | null>((resolve) => {