@gopherhole/sdk 0.2.1 → 0.2.2

package/dist/index.d.mts

@@ -304,6 +304,8 @@ interface GopherHoleOptions {
     maxReconnectAttempts?: number;
     /** Default request timeout in ms (default: 30000) */
     requestTimeout?: number;
+    /** Default message response timeout in ms (default: 30000) */
+    messageTimeout?: number;
 }
 /** Agent card configuration for registration */
 interface AgentCardConfig {
@@ -397,12 +399,17 @@ declare class GopherHole extends EventEmitter<EventMap> {
     private reconnectDelay;
     private maxReconnectAttempts;
     private requestTimeout;
+    private messageTimeout;
     private reconnectAttempts;
     private reconnectTimer;
     private pingInterval;
     private agentId;
     private agentCard;
     constructor(apiKeyOrOptions: string | GopherHoleOptions);
+    /**
+     * Get the configured message timeout
+     */
+    getMessageTimeout(): number;
     /**
      * Update agent card (sends to hub if connected)
      */
@@ -457,12 +464,28 @@ declare class GopherHole extends EventEmitter<EventMap> {
      * Cancel a task
      */
     cancelTask(taskId: string): Promise<Task>;
+    /**
+     * Respond to an incoming task via WebSocket (completes the task)
+     * Use this when you receive a 'message' event and want to send back a response
+     * that completes the original task.
+     */
+    respond(taskId: string, text: string, options?: {
+        status?: 'completed' | 'failed';
+        message?: string;
+    }): void;
+    /**
+     * Respond with a failure to an incoming task
+     */
+    respondError(taskId: string, errorMessage: string): void;
     /**
      * Reply to a message/task (sends back to the original caller)
+     * Note: This creates a NEW task via HTTP. For completing an existing task,
+     * use respond() instead.
      */
     reply(taskId: string, payload: MessagePayload, toAgentId?: string): Promise<Task>;
     /**
-     * Reply with text
+     * Reply with text (creates new task)
+     * Note: For completing an existing task, use respond() instead.
      */
     replyText(taskId: string, text: string): Promise<Task>;
     /**

package/dist/index.d.ts

@@ -304,6 +304,8 @@ interface GopherHoleOptions {
     maxReconnectAttempts?: number;
     /** Default request timeout in ms (default: 30000) */
     requestTimeout?: number;
+    /** Default message response timeout in ms (default: 30000) */
+    messageTimeout?: number;
 }
 /** Agent card configuration for registration */
 interface AgentCardConfig {
@@ -397,12 +399,17 @@ declare class GopherHole extends EventEmitter<EventMap> {
     private reconnectDelay;
     private maxReconnectAttempts;
     private requestTimeout;
+    private messageTimeout;
     private reconnectAttempts;
     private reconnectTimer;
     private pingInterval;
     private agentId;
     private agentCard;
     constructor(apiKeyOrOptions: string | GopherHoleOptions);
+    /**
+     * Get the configured message timeout
+     */
+    getMessageTimeout(): number;
     /**
      * Update agent card (sends to hub if connected)
      */
@@ -457,12 +464,28 @@ declare class GopherHole extends EventEmitter<EventMap> {
      * Cancel a task
      */
     cancelTask(taskId: string): Promise<Task>;
+    /**
+     * Respond to an incoming task via WebSocket (completes the task)
+     * Use this when you receive a 'message' event and want to send back a response
+     * that completes the original task.
+     */
+    respond(taskId: string, text: string, options?: {
+        status?: 'completed' | 'failed';
+        message?: string;
+    }): void;
+    /**
+     * Respond with a failure to an incoming task
+     */
+    respondError(taskId: string, errorMessage: string): void;
     /**
      * Reply to a message/task (sends back to the original caller)
+     * Note: This creates a NEW task via HTTP. For completing an existing task,
+     * use respond() instead.
      */
     reply(taskId: string, payload: MessagePayload, toAgentId?: string): Promise<Task>;
     /**
-     * Reply with text
+     * Reply with text (creates new task)
+     * Note: For completing an existing task, use respond() instead.
      */
     replyText(taskId: string, text: string): Promise<Task>;
     /**

package/dist/index.js

@@ -259,6 +259,13 @@ var GopherHole = class extends import_eventemitter3.EventEmitter {
     this.reconnectDelay = options.reconnectDelay ?? 1e3;
     this.maxReconnectAttempts = options.maxReconnectAttempts ?? 10;
     this.requestTimeout = options.requestTimeout ?? 3e4;
+    this.messageTimeout = options.messageTimeout ?? 3e4;
+  }
+  /**
+   * Get the configured message timeout
+   */
+  getMessageTimeout() {
+    return this.messageTimeout;
   }
   /**
    * Update agent card (sends to hub if connected)
@@ -407,8 +414,41 @@ var GopherHole = class extends import_eventemitter3.EventEmitter {
     const response = await this.rpc("tasks/cancel", { id: taskId });
     return response;
   }
+  /**
+   * Respond to an incoming task via WebSocket (completes the task)
+   * Use this when you receive a 'message' event and want to send back a response
+   * that completes the original task.
+   */
+  respond(taskId, text, options) {
+    if (!this.ws || this.ws.readyState !== 1) {
+      throw new Error("WebSocket not connected");
+    }
+    const response = {
+      type: "task_response",
+      taskId,
+      status: {
+        state: options?.status ?? "completed",
+        message: options?.message
+      },
+      artifact: {
+        artifactId: `response-${Date.now()}`,
+        mimeType: "text/plain",
+        parts: [{ kind: "text", text }]
+      },
+      lastChunk: true
+    };
+    this.ws.send(JSON.stringify(response));
+  }
+  /**
+   * Respond with a failure to an incoming task
+   */
+  respondError(taskId, errorMessage) {
+    this.respond(taskId, errorMessage, { status: "failed", message: errorMessage });
+  }
   /**
    * Reply to a message/task (sends back to the original caller)
+   * Note: This creates a NEW task via HTTP. For completing an existing task,
+   * use respond() instead.
    */
   async reply(taskId, payload, toAgentId) {
     if (!toAgentId) {
@@ -431,7 +471,8 @@ var GopherHole = class extends import_eventemitter3.EventEmitter {
     return response;
   }
   /**
-   * Reply with text
+   * Reply with text (creates new task)
+   * Note: For completing an existing task, use respond() instead.
    */
   async replyText(taskId, text) {
     return this.reply(taskId, {

package/dist/index.mjs

@@ -238,6 +238,13 @@ var GopherHole = class extends EventEmitter {
     this.reconnectDelay = options.reconnectDelay ?? 1e3;
     this.maxReconnectAttempts = options.maxReconnectAttempts ?? 10;
     this.requestTimeout = options.requestTimeout ?? 3e4;
+    this.messageTimeout = options.messageTimeout ?? 3e4;
+  }
+  /**
+   * Get the configured message timeout
+   */
+  getMessageTimeout() {
+    return this.messageTimeout;
   }
   /**
    * Update agent card (sends to hub if connected)
@@ -386,8 +393,41 @@ var GopherHole = class extends EventEmitter {
     const response = await this.rpc("tasks/cancel", { id: taskId });
     return response;
   }
+  /**
+   * Respond to an incoming task via WebSocket (completes the task)
+   * Use this when you receive a 'message' event and want to send back a response
+   * that completes the original task.
+   */
+  respond(taskId, text, options) {
+    if (!this.ws || this.ws.readyState !== 1) {
+      throw new Error("WebSocket not connected");
+    }
+    const response = {
+      type: "task_response",
+      taskId,
+      status: {
+        state: options?.status ?? "completed",
+        message: options?.message
+      },
+      artifact: {
+        artifactId: `response-${Date.now()}`,
+        mimeType: "text/plain",
+        parts: [{ kind: "text", text }]
+      },
+      lastChunk: true
+    };
+    this.ws.send(JSON.stringify(response));
+  }
+  /**
+   * Respond with a failure to an incoming task
+   */
+  respondError(taskId, errorMessage) {
+    this.respond(taskId, errorMessage, { status: "failed", message: errorMessage });
+  }
   /**
    * Reply to a message/task (sends back to the original caller)
+   * Note: This creates a NEW task via HTTP. For completing an existing task,
+   * use respond() instead.
    */
   async reply(taskId, payload, toAgentId) {
     if (!toAgentId) {
@@ -410,7 +450,8 @@ var GopherHole = class extends EventEmitter {
     return response;
   }
   /**
-   * Reply with text
+   * Reply with text (creates new task)
+   * Note: For completing an existing task, use respond() instead.
    */
   async replyText(taskId, text) {
     return this.reply(taskId, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gopherhole/sdk",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "GopherHole SDK - Connect AI agents via the A2A protocol",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/index.ts

@@ -34,6 +34,8 @@ export interface GopherHoleOptions {
   maxReconnectAttempts?: number;
   /** Default request timeout in ms (default: 30000) */
   requestTimeout?: number;
+  /** Default message response timeout in ms (default: 30000) */
+  messageTimeout?: number;
 }
 
 /** Agent card configuration for registration */
@@ -178,6 +180,7 @@ export class GopherHole extends EventEmitter<EventMap> {
   private reconnectDelay: number;
   private maxReconnectAttempts: number;
   private requestTimeout: number;
+  private messageTimeout: number;
   private reconnectAttempts = 0;
   private reconnectTimer: ReturnType<typeof setTimeout> | null = null;
   private pingInterval: ReturnType<typeof setInterval> | null = null;
@@ -199,6 +202,14 @@ export class GopherHole extends EventEmitter<EventMap> {
     this.reconnectDelay = options.reconnectDelay ?? 1000;
     this.maxReconnectAttempts = options.maxReconnectAttempts ?? 10;
     this.requestTimeout = options.requestTimeout ?? 30000;
+    this.messageTimeout = options.messageTimeout ?? 30000;
+  }
+  
+  /**
+   * Get the configured message timeout
+   */
+  getMessageTimeout(): number {
+    return this.messageTimeout;
   }
   
   /**
@@ -378,8 +389,45 @@ export class GopherHole extends EventEmitter<EventMap> {
     return response as Task;
   }
 
+  /**
+   * Respond to an incoming task via WebSocket (completes the task)
+   * Use this when you receive a 'message' event and want to send back a response
+   * that completes the original task.
+   */
+  respond(taskId: string, text: string, options?: { status?: 'completed' | 'failed'; message?: string }): void {
+    if (!this.ws || this.ws.readyState !== 1) {
+      throw new Error('WebSocket not connected');
+    }
+
+    const response = {
+      type: 'task_response',
+      taskId,
+      status: { 
+        state: options?.status ?? 'completed',
+        message: options?.message,
+      },
+      artifact: {
+        artifactId: `response-${Date.now()}`,
+        mimeType: 'text/plain',
+        parts: [{ kind: 'text', text }],
+      },
+      lastChunk: true,
+    };
+
+    this.ws.send(JSON.stringify(response));
+  }
+
+  /**
+   * Respond with a failure to an incoming task
+   */
+  respondError(taskId: string, errorMessage: string): void {
+    this.respond(taskId, errorMessage, { status: 'failed', message: errorMessage });
+  }
+
   /**
    * Reply to a message/task (sends back to the original caller)
+   * Note: This creates a NEW task via HTTP. For completing an existing task,
+   * use respond() instead.
    */
   async reply(taskId: string, payload: MessagePayload, toAgentId?: string): Promise<Task> {
     // If toAgentId not provided, we need to figure out who to reply to
@@ -410,7 +458,8 @@ export class GopherHole extends EventEmitter<EventMap> {
   }
 
   /**
-   * Reply with text
+   * Reply with text (creates new task)
+   * Note: For completing an existing task, use respond() instead.
    */
   async replyText(taskId: string, text: string): Promise<Task> {
     return this.reply(taskId, {