aap-agent-client 2.5.0 → 2.7.0

package/index.js

@@ -8,6 +8,22 @@
 import { Prover } from './prover.js';
 import { Identity } from 'aap-agent-core';
 
+// Fetch with timeout helper
+async function fetchWithTimeout(url, options = {}, timeoutMs = 30000) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal
+    });
+    return response;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
 /**
  * AAP Client - High-level interface for verification
  */
@@ -47,11 +63,19 @@ export class AAPClient {
 
     const callback = solutionOrCallback || this.llmCallback;
 
-    // Step 1: Request challenge
-    const challengeRes = await fetch(`${baseUrl}/challenge`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' }
-    });
+    // Step 1: Request challenge (with timeout)
+    let challengeRes;
+    try {
+      challengeRes = await fetchWithTimeout(`${baseUrl}/challenge`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' }
+      }, 10000);
+    } catch (error) {
+      if (error.name === 'AbortError') {
+        throw new Error('Challenge request timed out');
+      }
+      throw error;
+    }
 
     if (!challengeRes.ok) {
       throw new Error(`Failed to get challenge: ${challengeRes.status}`);
@@ -62,12 +86,20 @@ export class AAPClient {
     // Step 2: Generate proof
     const proof = await this.prover.generateProof(challenge, callback);
 
-    // Step 3: Submit proof
-    const verifyRes = await fetch(`${baseUrl}/verify`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(proof)
-    });
+    // Step 3: Submit proof (with timeout)
+    let verifyRes;
+    try {
+      verifyRes = await fetchWithTimeout(`${baseUrl}/verify`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(proof)
+      }, 15000);
+    } catch (error) {
+      if (error.name === 'AbortError') {
+        throw new Error('Verification request timed out');
+      }
+      throw error;
+    }
 
     const result = await verifyRes.json();
 
@@ -176,4 +208,7 @@ export function createClient(options) {
 // Re-export Prover
 export { Prover };
 
+// WebSocket client (v2.7+)
+export { AAPWebSocketClient, createSolver, verifyWithWebSocket } from './websocket.js';
+
 export default { AAPClient, createClient, Prover };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aap-agent-client",
-  "version": "2.5.0",
+  "version": "2.7.0",
   "description": "Client library for Agent Attestation Protocol - prove your AI agent identity",
   "main": "index.js",
   "types": "index.d.ts",
@@ -20,7 +20,8 @@
   },
   "homepage": "https://github.com/ira-hash/agent-attestation-protocol#readme",
   "dependencies": {
-    "aap-agent-core": "^2.5.0"
+    "aap-agent-core": "^2.6.0",
+    "ws": "^8.16.0"
   },
   "engines": {
     "node": ">=18.0.0"

package/prover.js

@@ -47,10 +47,20 @@ export class Prover {
     
     if (llmCallback) {
       // Use LLM to solve all at once (more efficient)
-      const combinedPrompt = this.createBatchPrompt(challenges);
-      const llmResponse = await llmCallback(combinedPrompt);
-      const parsedSolutions = this.parseBatchResponse(llmResponse, challenges.length);
-      solutions.push(...parsedSolutions);
+      try {
+        const combinedPrompt = this.createBatchPrompt(challenges);
+        const llmResponse = await llmCallback(combinedPrompt);
+        const parsedSolutions = this.parseBatchResponse(llmResponse, challenges.length);
+        solutions.push(...parsedSolutions);
+      } catch (error) {
+        console.error('[AAP] LLM callback failed:', error.message);
+        // Fallback to placeholder solutions (will fail verification but won't crash)
+        for (const c of challenges) {
+          const saltMatch = c.challenge_string.match(/\[REQ-([A-Z0-9]+)\]/);
+          const salt = saltMatch ? saltMatch[1] : 'ERROR';
+          solutions.push(JSON.stringify({ salt, error: 'LLM callback failed' }));
+        }
+      }
     } else {
       // Use built-in solvers
       for (const challenge of challenges) {

package/websocket.js

@@ -0,0 +1,162 @@
+/**
+ * AAP WebSocket Client v2.7
+ * 
+ * Connects to AAP WebSocket server, receives sequential challenges,
+ * and responds in real-time.
+ */
+
+import WebSocket from 'ws';
+import { Identity } from 'aap-agent-core';
+
+const PROTOCOL_VERSION = '2.7.0';
+
+/**
+ * AAP WebSocket Client
+ */
+export class AAPWebSocketClient {
+  constructor(options = {}) {
+    this.serverUrl = options.serverUrl || 'ws://localhost:3000/aap';
+    this.identity = options.identity || new Identity(options);
+    this.llmCallback = options.llmCallback || null;
+    this.autoSolve = options.autoSolve !== false;
+  }
+  
+  /**
+   * Get public identity info
+   */
+  getIdentity() {
+    return this.identity.getPublic();
+  }
+  
+  /**
+   * Connect and verify
+   * @param {Function} [llmCallback] - async (challengeString) => solutionObject
+   * @returns {Promise<Object>} Verification result
+   */
+  async verify(llmCallback) {
+    const solver = llmCallback || this.llmCallback;
+    
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(this.serverUrl);
+      let sessionId = null;
+      let result = null;
+      
+      ws.on('open', () => {
+        // Wait for handshake
+      });
+      
+      ws.on('message', async (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          
+          switch (msg.type) {
+            case 'handshake':
+              sessionId = msg.sessionId;
+              // Send ready with identity
+              const identity = this.identity.getPublic();
+              ws.send(JSON.stringify({
+                type: 'ready',
+                publicKey: identity.publicKey,
+                publicId: identity.publicId
+              }));
+              break;
+              
+            case 'challenge':
+              // Solve challenge
+              if (!solver) {
+                ws.send(JSON.stringify({
+                  type: 'answer',
+                  answer: {}  // Empty - will fail
+                }));
+                break;
+              }
+              
+              try {
+                const answer = await solver(msg.challenge, msg.id);
+                ws.send(JSON.stringify({
+                  type: 'answer',
+                  answer
+                }));
+              } catch (e) {
+                ws.send(JSON.stringify({
+                  type: 'answer',
+                  answer: { error: e.message }
+                }));
+              }
+              break;
+              
+            case 'ack':
+              // Challenge acknowledged, wait for next
+              break;
+              
+            case 'timeout':
+              // Too slow
+              break;
+              
+            case 'result':
+              result = msg;
+              ws.close();
+              break;
+              
+            case 'error':
+              reject(new Error(msg.message));
+              ws.close();
+              break;
+          }
+        } catch (e) {
+          reject(e);
+        }
+      });
+      
+      ws.on('close', () => {
+        if (result) {
+          resolve(result);
+        } else {
+          reject(new Error('Connection closed without result'));
+        }
+      });
+      
+      ws.on('error', (err) => {
+        reject(err);
+      });
+    });
+  }
+}
+
+/**
+ * Create solver function from LLM
+ * @param {Function} llm - async (prompt) => response string
+ * @returns {Function} Solver function
+ */
+export function createSolver(llm) {
+  return async (challengeString, challengeId) => {
+    const prompt = `Solve this challenge and respond with ONLY valid JSON (no markdown, no explanation):
+
+${challengeString}
+
+Important:
+- Include the exact salt from the challenge
+- Follow the response format exactly
+- Return ONLY the JSON object`;
+
+    const response = await llm(prompt);
+    
+    // Parse JSON from response
+    const jsonMatch = response.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      throw new Error('No JSON found in response');
+    }
+    
+    return JSON.parse(jsonMatch[0]);
+  };
+}
+
+/**
+ * Quick verify helper
+ */
+export async function verifyWithWebSocket(serverUrl, llmCallback) {
+  const client = new AAPWebSocketClient({ serverUrl, llmCallback });
+  return client.verify();
+}
+
+export default AAPWebSocketClient;