@gopherhole/sdk 0.1.0 → 0.1.2

package/dist/index.mjs

@@ -0,0 +1,440 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/index.ts
+import { EventEmitter } from "eventemitter3";
+
+// src/types.ts
+var JsonRpcErrorCodes = {
+  ParseError: -32700,
+  InvalidRequest: -32600,
+  MethodNotFound: -32601,
+  InvalidParams: -32602,
+  InternalError: -32603,
+  // A2A-specific errors
+  TaskNotFound: -32001,
+  TaskNotCancelable: -32002,
+  PushNotificationNotSupported: -32003,
+  UnsupportedOperation: -32004,
+  ContentTypeNotSupported: -32005,
+  InvalidAgentCard: -32006
+};
+
+// src/index.ts
+var DEFAULT_HUB_URL = "wss://gopherhole.helixdata.workers.dev/ws";
+var GopherHole = class extends EventEmitter {
+  constructor(apiKeyOrOptions) {
+    super();
+    this.ws = null;
+    this.reconnectAttempts = 0;
+    this.reconnectTimer = null;
+    this.pingInterval = null;
+    this.agentId = null;
+    this.agentCard = null;
+    const options = typeof apiKeyOrOptions === "string" ? { apiKey: apiKeyOrOptions } : apiKeyOrOptions;
+    this.apiKey = options.apiKey;
+    this.hubUrl = options.hubUrl || DEFAULT_HUB_URL;
+    this.apiUrl = this.hubUrl.replace("/ws", "").replace("wss://", "https://").replace("ws://", "http://");
+    this.agentCard = options.agentCard || null;
+    this.autoReconnect = options.autoReconnect ?? true;
+    this.reconnectDelay = options.reconnectDelay ?? 1e3;
+    this.maxReconnectAttempts = options.maxReconnectAttempts ?? 10;
+  }
+  /**
+   * Update agent card (sends to hub if connected)
+   */
+  async updateCard(card) {
+    this.agentCard = card;
+    if (this.ws?.readyState === 1) {
+      this.ws.send(JSON.stringify({ type: "update_card", agentCard: card }));
+    }
+  }
+  /**
+   * Connect to the GopherHole hub via WebSocket
+   */
+  async connect() {
+    return new Promise((resolve, reject) => {
+      const WS = typeof WebSocket !== "undefined" ? WebSocket : __require("ws");
+      const ws = new WS(this.hubUrl, {
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`
+        }
+      });
+      this.ws = ws;
+      ws.onopen = () => {
+        this.reconnectAttempts = 0;
+        this.startPing();
+        this.emit("connect");
+        resolve();
+      };
+      ws.onclose = (event) => {
+        this.stopPing();
+        const reason = event.reason || "Connection closed";
+        this.emit("disconnect", reason);
+        if (this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+          this.scheduleReconnect();
+        }
+      };
+      ws.onerror = () => {
+        const error = new Error("WebSocket error");
+        this.emit("error", error);
+        reject(error);
+      };
+      ws.onmessage = (event) => {
+        try {
+          const data = JSON.parse(event.data.toString());
+          this.handleMessage(data);
+        } catch {
+          this.emit("error", new Error("Failed to parse message"));
+        }
+      };
+    });
+  }
+  /**
+   * Disconnect from the hub
+   */
+  disconnect() {
+    this.autoReconnect = false;
+    this.stopPing();
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+  /**
+   * Send a message to another agent
+   */
+  async send(toAgentId, payload, options) {
+    const response = await this.rpc("message/send", {
+      message: payload,
+      configuration: {
+        agentId: toAgentId,
+        ...options
+      }
+    });
+    return response;
+  }
+  /**
+   * Send a text message to another agent
+   */
+  async sendText(toAgentId, text, options) {
+    return this.send(toAgentId, {
+      role: "agent",
+      parts: [{ kind: "text", text }]
+    }, options);
+  }
+  /**
+   * Get a task by ID
+   */
+  async getTask(taskId, historyLength) {
+    const response = await this.rpc("tasks/get", {
+      id: taskId,
+      historyLength
+    });
+    return response;
+  }
+  /**
+   * List tasks
+   */
+  async listTasks(options) {
+    const response = await this.rpc("tasks/list", options || {});
+    return response;
+  }
+  /**
+   * Cancel a task
+   */
+  async cancelTask(taskId) {
+    const response = await this.rpc("tasks/cancel", { id: taskId });
+    return response;
+  }
+  /**
+   * Reply to a message/task (sends back to the original caller)
+   */
+  async reply(taskId, payload, toAgentId) {
+    if (!toAgentId) {
+      const task = await this.getTask(taskId);
+      const response2 = await this.rpc("message/send", {
+        message: payload,
+        configuration: {
+          contextId: task.contextId
+          // Server needs to handle replies via context routing
+        }
+      });
+      return response2;
+    }
+    const response = await this.rpc("message/send", {
+      message: payload,
+      configuration: {
+        agentId: toAgentId
+      }
+    });
+    return response;
+  }
+  /**
+   * Reply with text
+   */
+  async replyText(taskId, text) {
+    return this.reply(taskId, {
+      role: "agent",
+      parts: [{ kind: "text", text }]
+    });
+  }
+  /**
+   * Make a JSON-RPC call to the A2A endpoint
+   */
+  async rpc(method, params) {
+    const response = await fetch(`${this.apiUrl}/a2a`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method,
+        params,
+        id: Date.now()
+      })
+    });
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(data.error.message || "RPC error");
+    }
+    return data.result;
+  }
+  /**
+   * Handle incoming WebSocket messages
+   */
+  handleMessage(data) {
+    if (data.type === "message") {
+      this.emit("message", {
+        from: data.from,
+        taskId: data.taskId,
+        payload: data.payload,
+        timestamp: data.timestamp || Date.now()
+      });
+    } else if (data.type === "task_update") {
+      this.emit("taskUpdate", data.task);
+    } else if (data.type === "pong") {
+    } else if (data.type === "welcome") {
+      this.agentId = data.agentId;
+      if (this.agentCard && this.ws?.readyState === 1) {
+        this.ws.send(JSON.stringify({ type: "update_card", agentCard: this.agentCard }));
+      }
+    } else if (data.type === "card_updated") {
+    } else if (data.type === "warning") {
+      console.warn("GopherHole warning:", data.message);
+    }
+  }
+  /**
+   * Start ping interval
+   */
+  startPing() {
+    this.pingInterval = setInterval(() => {
+      if (this.ws?.readyState === 1) {
+        this.ws.send(JSON.stringify({ type: "ping" }));
+      }
+    }, 3e4);
+  }
+  /**
+   * Stop ping interval
+   */
+  stopPing() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+  /**
+   * Schedule reconnection
+   */
+  scheduleReconnect() {
+    if (this.reconnectTimer) return;
+    this.reconnectAttempts++;
+    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+    this.reconnectTimer = setTimeout(async () => {
+      this.reconnectTimer = null;
+      try {
+        await this.connect();
+      } catch {
+      }
+    }, delay);
+  }
+  /**
+   * Get connection state
+   */
+  get connected() {
+    return this.ws?.readyState === 1;
+  }
+  /**
+   * Get the agent ID (available after connect)
+   */
+  get id() {
+    return this.agentId;
+  }
+  // ============================================================
+  // DISCOVERY METHODS
+  // ============================================================
+  /**
+   * Discover public agents with comprehensive search
+   */
+  async discover(options) {
+    const params = new URLSearchParams();
+    if (options?.query) params.set("q", options.query);
+    if (options?.category) params.set("category", options.category);
+    if (options?.tag) params.set("tag", options.tag);
+    if (options?.skillTag) params.set("skillTag", options.skillTag);
+    if (options?.contentMode) params.set("contentMode", options.contentMode);
+    if (options?.sort) params.set("sort", options.sort);
+    if (options?.limit) params.set("limit", String(options.limit));
+    if (options?.offset) params.set("offset", String(options.offset));
+    if (options?.scope) params.set("scope", options.scope);
+    const response = await fetch(`${this.apiUrl}/api/discover/agents?${params}`, {
+      headers: {
+        "Authorization": `Bearer ${this.apiKey}`
+      }
+    });
+    return response.json();
+  }
+  /**
+   * Discover all agents in your tenant (no limit)
+   */
+  async discoverTenantAgents() {
+    return this.discover({ scope: "tenant" });
+  }
+  /**
+   * Search agents with fuzzy matching on description
+   */
+  async searchAgents(query, options) {
+    return this.discover({ ...options, query });
+  }
+  /**
+   * Find agents by category
+   */
+  async findByCategory(category, options) {
+    return this.discover({ ...options, category });
+  }
+  /**
+   * Find agents by tag
+   */
+  async findByTag(tag, options) {
+    return this.discover({ ...options, tag });
+  }
+  /**
+   * Find agents by skill tag (searches within agent skills)
+   */
+  async findBySkillTag(skillTag, options) {
+    return this.discover({ ...options, skillTag });
+  }
+  /**
+   * Find agents that support a specific input/output mode
+   */
+  async findByContentMode(mode, options) {
+    return this.discover({ ...options, contentMode: mode });
+  }
+  /**
+   * Get top-rated agents
+   */
+  async getTopRated(limit = 10) {
+    return this.discover({ sort: "rating", limit });
+  }
+  /**
+   * Get most popular agents (by usage)
+   */
+  async getPopular(limit = 10) {
+    return this.discover({ sort: "popular", limit });
+  }
+  /**
+   * Get featured/curated agents
+   */
+  async getFeatured() {
+    const response = await fetch(`${this.apiUrl}/api/discover/featured`);
+    return response.json();
+  }
+  /**
+   * Get available categories
+   */
+  async getCategories() {
+    const response = await fetch(`${this.apiUrl}/api/discover/categories`);
+    return response.json();
+  }
+  /**
+   * Get detailed info about a public agent
+   */
+  async getAgentInfo(agentId) {
+    const response = await fetch(`${this.apiUrl}/api/discover/agents/${agentId}`);
+    if (!response.ok) {
+      throw new Error("Agent not found");
+    }
+    return response.json();
+  }
+  /**
+   * Rate an agent (requires authentication)
+   */
+  async rateAgent(agentId, rating, review) {
+    const response = await fetch(`${this.apiUrl}/api/discover/agents/${agentId}/rate`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify({ rating, review })
+    });
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error || "Failed to rate agent");
+    }
+    return response.json();
+  }
+  /**
+   * Get best agent for a task using smart matching
+   * Searches by query and returns the top-rated match
+   */
+  async findBestAgent(query, options) {
+    const result = await this.discover({
+      query,
+      category: options?.category,
+      sort: "rating",
+      limit: 10
+    });
+    const agents = result.agents.filter((agent) => {
+      if (options?.minRating && agent.avgRating < options.minRating) return false;
+      if (options?.pricing === "free" && agent.pricing !== "free") return false;
+      if (options?.pricing === "paid" && agent.pricing === "free") return false;
+      return true;
+    });
+    return agents[0] || null;
+  }
+  /**
+   * Find agents similar to a given agent
+   */
+  async findSimilar(agentId, limit = 5) {
+    const info = await this.getAgentInfo(agentId);
+    const agent = info.agent;
+    if (agent.category) {
+      const result = await this.discover({
+        category: agent.category,
+        sort: "rating",
+        limit: limit + 1
+        // +1 to exclude self
+      });
+      result.agents = result.agents.filter((a) => a.id !== agentId).slice(0, limit);
+      return result;
+    }
+    return this.getTopRated(limit);
+  }
+};
+var index_default = GopherHole;
+export {
+  GopherHole,
+  JsonRpcErrorCodes,
+  index_default as default
+};

package/package.json

@@ -1,20 +1,52 @@
 {
   "name": "@gopherhole/sdk",
-  "version": "0.1.0",
-  "description": "GopherHole Agent Hub SDK",
-  "type": "module",
+  "version": "0.1.2",
+  "description": "GopherHole SDK - Connect AI agents via the A2A protocol",
   "main": "dist/index.js",
+  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
   "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch"
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "a2a",
+    "ai",
+    "agents",
+    "gopherhole",
+    "sdk",
+    "google-a2a"
+  ],
+  "author": "GopherHole",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gopherhole/sdk"
   },
   "dependencies": {
-    "ws": "^8.16.0"
+    "ws": "^8.16.0",
+    "eventemitter3": "^5.0.1"
   },
   "devDependencies": {
     "@types/node": "^20.11.0",
     "@types/ws": "^8.5.10",
-    "typescript": "^5.3.3"
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.7.0"
+  },
+  "peerDependenciesMeta": {
+    "typescript": {
+      "optional": true
+    }
   }
 }