@gopherhole/sdk 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,207 +1,459 @@
-import WebSocket from 'ws';
-import { EventEmitter } from 'events';
-export class GopherHole extends EventEmitter {
-    apiKey;
-    hubUrl;
-    ws = null;
-    reconnect;
-    reconnectDelay;
-    authenticated = false;
-    pendingMessages = new Map();
-    messageCounter = 0;
-    agentId = null;
-    constructor(apiKey, options = {}) {
-        super();
-        this.apiKey = apiKey;
-        this.hubUrl = options.hubUrl || 'wss://gopherhole.ai/ws';
-        this.reconnect = options.reconnect ?? true;
-        this.reconnectDelay = options.reconnectDelay ?? 5000;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  GopherHole: () => GopherHole,
+  JsonRpcErrorCodes: () => JsonRpcErrorCodes,
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+var import_eventemitter3 = require("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 import_eventemitter3.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 }));
     }
-    async connect() {
-        return new Promise((resolve, reject) => {
-            try {
-                this.ws = new WebSocket(this.hubUrl);
-                this.ws.on('open', () => {
-                    console.log('[GopherHole] Connected, authenticating...');
-                    this.ws.send(JSON.stringify({ type: 'auth', token: this.apiKey }));
-                });
-                this.ws.on('message', (data) => {
-                    try {
-                        const msg = JSON.parse(data.toString());
-                        this.handleMessage(msg, resolve, reject);
-                    }
-                    catch (err) {
-                        console.error('[GopherHole] Failed to parse message:', err);
-                    }
-                });
-                this.ws.on('close', () => {
-                    console.log('[GopherHole] Disconnected');
-                    this.authenticated = false;
-                    this.emit('disconnect');
-                    if (this.reconnect) {
-                        console.log(`[GopherHole] Reconnecting in ${this.reconnectDelay}ms...`);
-                        setTimeout(() => this.connect(), this.reconnectDelay);
-                    }
-                });
-                this.ws.on('error', (err) => {
-                    console.error('[GopherHole] WebSocket error:', err);
-                    this.emit('error', err);
-                    if (!this.authenticated) {
-                        reject(err);
-                    }
-                });
-            }
-            catch (err) {
-                reject(err);
-            }
-        });
-    }
-    handleMessage(msg, resolve, reject) {
-        switch (msg.type) {
-            case 'auth_ok':
-                console.log(`[GopherHole] Authenticated as ${msg.agentId}`);
-                this.authenticated = true;
-                this.agentId = msg.agentId || null;
-                this.emit('connected', { agentId: this.agentId });
-                resolve?.();
-                break;
-            case 'auth_error':
-                console.error('[GopherHole] Auth failed:', msg.error);
-                reject?.(new Error(msg.error || 'Authentication failed'));
-                break;
-            case 'message':
-                const incomingMsg = {
-                    from: msg.from,
-                    to: msg.to,
-                    payload: msg.payload,
-                    timestamp: msg.timestamp || Date.now(),
-                };
-                console.log(`[GopherHole] Message from ${msg.from}`);
-                this.emit('message', incomingMsg);
-                break;
-            case 'ack':
-                const pending = this.pendingMessages.get(msg.id);
-                if (pending) {
-                    pending.resolve({ id: msg.id, timestamp: msg.timestamp });
-                    this.pendingMessages.delete(msg.id);
-                }
-                break;
-            case 'error':
-                console.error('[GopherHole] Error:', msg.error);
-                const pendingErr = msg.id ? this.pendingMessages.get(msg.id) : null;
-                if (pendingErr) {
-                    pendingErr.reject(new Error(msg.error));
-                    this.pendingMessages.delete(msg.id);
-                }
-                this.emit('error', new Error(msg.error));
-                break;
-            default:
-                console.log('[GopherHole] Unknown message type:', msg.type);
+  }
+  /**
+   * 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}`
         }
-    }
-    async send(to, payload) {
-        if (!this.authenticated || !this.ws) {
-            throw new Error('Not connected');
+      });
+      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();
         }
-        const id = `msg-${++this.messageCounter}-${Date.now()}`;
-        return new Promise((resolve, reject) => {
-            this.pendingMessages.set(id, { resolve: resolve, reject });
-            this.ws.send(JSON.stringify({
-                type: 'message',
-                id,
-                to,
-                payload,
-            }));
-            // Timeout after 30s
-            setTimeout(() => {
-                if (this.pendingMessages.has(id)) {
-                    this.pendingMessages.delete(id);
-                    reject(new Error('Message send timeout'));
-                }
-            }, 30000);
-        });
+      };
+      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;
     }
-    sendText(to, text, contextId) {
-        return this.send(to, {
-            parts: [{ kind: 'text', text }],
-            contextId,
-        });
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
     }
-    disconnect() {
-        this.reconnect = false;
-        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;
     }
-    isConnected() {
-        return this.authenticated && this.ws?.readyState === WebSocket.OPEN;
+    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");
     }
-    /**
-     * Create a GopherHole instance from environment variables
-     * Reads GOPHERHOLE_API_KEY and optionally GOPHERHOLE_HUB_URL
-     */
-    static fromEnv(options = {}) {
-        const apiKey = process.env.GOPHERHOLE_API_KEY;
-        if (!apiKey) {
-            throw new Error('GOPHERHOLE_API_KEY environment variable is required');
-        }
-        return new GopherHole(apiKey, {
-            ...options,
-            hubUrl: process.env.GOPHERHOLE_HUB_URL || 'wss://gopherhole.ai/ws',
-        });
+    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);
     }
-    /**
-     * Create a simple agent with a message handler
-     */
-    static agent(config) {
-        const apiKey = config.apiKey || process.env.GOPHERHOLE_API_KEY;
-        if (!apiKey) {
-            throw new Error('API key required: pass apiKey or set GOPHERHOLE_API_KEY');
-        }
-        const hub = new GopherHole(apiKey, {
-            hubUrl: config.hubUrl || process.env.GOPHERHOLE_HUB_URL,
-        });
-        hub.on('message', async (msg) => {
-            try {
-                const response = await config.onMessage(msg, hub);
-                // If handler returns a response, send it back
-                if (response) {
-                    if (typeof response === 'string') {
-                        await hub.sendText(msg.from, response);
-                    }
-                    else {
-                        await hub.send(msg.from, response);
-                    }
-                }
-            }
-            catch (err) {
-                console.error('[GopherHole Agent] Message handler error:', err);
-                if (config.onError) {
-                    config.onError(err, hub);
-                }
-            }
-        });
-        hub.on('connected', () => {
-            console.log(`[GopherHole Agent] Connected as ${hub.agentId}`);
-            if (config.onConnect) {
-                config.onConnect(hub);
-            }
-        });
-        hub.on('error', (err) => {
-            if (config.onError) {
-                config.onError(err, hub);
-            }
-        });
-        return {
-            hub,
-            start: async () => {
-                await hub.connect();
-            },
-            stop: () => {
-                hub.disconnect();
-            },
-        };
+  }
+  /**
+   * 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;
     }
-}
-export default GopherHole;
+    return this.getTopRated(limit);
+  }
+};
+var index_default = GopherHole;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GopherHole,
+  JsonRpcErrorCodes
+});