aap-agent-client 3.0.0 → 3.2.0

package/index.js

@@ -1,13 +1,38 @@
 /**
- * @aap/client v3.0.0
+ * @aap/client v3.2.0
  * 
- * WebSocket client for Agent Attestation Protocol.
- * Connect, solve sequential challenges, prove your intelligence.
+ * WebSocket client with mandatory signature.
+ * Proves cryptographic identity via secp256k1.
  */
 
 import WebSocket from 'ws';
+import { generateKeyPairSync, createSign, createHash, randomBytes } from 'crypto';
 
-export const PROTOCOL_VERSION = '3.0.0';
+export const PROTOCOL_VERSION = '3.2.0';
+
+/**
+ * Generate secp256k1 key pair for agent identity
+ */
+export function generateIdentity() {
+  const { publicKey, privateKey } = generateKeyPairSync('ec', {
+    namedCurve: 'secp256k1',
+    publicKeyEncoding: { type: 'spki', format: 'pem' },
+    privateKeyEncoding: { type: 'pkcs8', format: 'pem' }
+  });
+  
+  const publicId = createHash('sha256').update(publicKey).digest('hex').slice(0, 16);
+  
+  return { publicKey, privateKey, publicId };
+}
+
+/**
+ * Sign data with private key
+ */
+export function sign(data, privateKey) {
+  const signer = createSign('SHA256');
+  signer.update(data);
+  return signer.sign(privateKey, 'base64');
+}
 
 /**
  * AAP WebSocket Client
@@ -15,25 +40,28 @@ export const PROTOCOL_VERSION = '3.0.0';
 export class AAPClient {
   constructor(options = {}) {
     this.serverUrl = options.serverUrl || 'ws://localhost:3000/aap';
-    this.publicId = options.publicId || null;
+    this.identity = options.identity || generateIdentity();
     this.solver = options.solver || null;
   }
 
+  get publicKey() { return this.identity.publicKey; }
+  get publicId() { return this.identity.publicId; }
+
   /**
-   * Connect and verify
-   * @param {Function} [solver] - async (challengeString, challengeId) => answerObject
+   * Connect and verify with signature
+   * @param {Function} [solver] - async (challenges) => answers[]
    * @returns {Promise<Object>} Verification result
    */
   async verify(solver) {
     const solve = solver || this.solver;
+    const { publicKey, privateKey, publicId } = this.identity;
     
     return new Promise((resolve, reject) => {
       const ws = new WebSocket(this.serverUrl);
       let result = null;
+      let nonce = null;
 
-      ws.on('open', () => {
-        // Wait for handshake
-      });
+      ws.on('open', () => {});
 
       ws.on('message', async (data) => {
         try {
@@ -41,36 +69,44 @@ export class AAPClient {
 
           switch (msg.type) {
             case 'handshake':
-              // Send ready
+              // Send ready with public key
               ws.send(JSON.stringify({
                 type: 'ready',
-                publicId: this.publicId
+                publicKey
               }));
               break;
 
-            case 'challenge':
+            case 'challenges':
+              nonce = msg.nonce;
+              
               if (!solve) {
-                // No solver - send empty answer (will fail)
-                ws.send(JSON.stringify({ type: 'answer', answer: {} }));
+                // No solver - will fail
+                const timestamp = Date.now();
+                const answers = [];
+                const proofData = JSON.stringify({ nonce, answers, publicId, timestamp });
+                const signature = sign(proofData, privateKey);
+                ws.send(JSON.stringify({ type: 'answers', answers, signature, timestamp }));
                 break;
               }
 
               try {
-                const answer = await solve(msg.challenge, msg.id);
-                ws.send(JSON.stringify({ type: 'answer', answer }));
+                const answers = await solve(msg.challenges);
+                const timestamp = Date.now();
+                
+                // Sign the proof
+                const proofData = JSON.stringify({ nonce, answers, publicId, timestamp });
+                const signature = sign(proofData, privateKey);
+                
+                ws.send(JSON.stringify({ type: 'answers', answers, signature, timestamp }));
               } catch (e) {
-                ws.send(JSON.stringify({ type: 'answer', answer: { error: e.message } }));
+                const timestamp = Date.now();
+                const answers = [];
+                const proofData = JSON.stringify({ nonce, answers, publicId, timestamp });
+                const signature = sign(proofData, privateKey);
+                ws.send(JSON.stringify({ type: 'answers', answers, signature, timestamp }));
               }
               break;
 
-            case 'ack':
-              // Challenge acknowledged, waiting for next
-              break;
-
-            case 'timeout':
-              // Too slow
-              break;
-
             case 'result':
               result = msg;
               break;
@@ -87,16 +123,11 @@ export class AAPClient {
       });
 
       ws.on('close', () => {
-        if (result) {
-          resolve(result);
-        } else {
-          reject(new Error('Connection closed without result'));
-        }
+        if (result) resolve(result);
+        else reject(new Error('Connection closed without result'));
       });
 
-      ws.on('error', (err) => {
-        reject(err);
-      });
+      ws.on('error', reject);
     });
   }
 }
@@ -104,43 +135,33 @@ export class AAPClient {
 /**
  * Create a solver function from an LLM callback
  * @param {Function} llm - async (prompt) => responseString
- * @returns {Function} Solver function for verify()
+ * @returns {Function} Solver function
  */
 export function createSolver(llm) {
-  return async (challengeString, challengeId) => {
-    const prompt = `Solve this challenge. Respond with ONLY the JSON object, no explanation:
+  return async (challenges) => {
+    const prompt = `Solve ALL these challenges. Return a JSON array of answers in order.
 
-${challengeString}`;
+${challenges.map((c, i) => `[${i}] ${c.challenge}`).join('\n\n')}
+
+Respond with ONLY a JSON array like: [{...}, {...}, ...]`;
 
     const response = await llm(prompt);
-    
-    // Extract JSON from response
-    const match = response.match(/\{[\s\S]*?\}/);
-    if (!match) {
-      throw new Error('No JSON found in response');
-    }
-    
+    const match = response.match(/\[[\s\S]*\]/);
+    if (!match) throw new Error('No JSON array found');
     return JSON.parse(match[0]);
   };
 }
 
 /**
  * Quick verify helper
- * @param {string} serverUrl - WebSocket URL
- * @param {Function} [solver] - Solver function
- * @param {string} [publicId] - Public ID
- * @returns {Promise<Object>} Verification result
  */
-export async function verify(serverUrl, solver, publicId) {
-  const client = new AAPClient({ serverUrl, solver, publicId });
+export async function verify(serverUrl, solver, identity) {
+  const client = new AAPClient({ serverUrl, solver, identity });
   return client.verify();
 }
 
-/**
- * Create client instance
- */
 export function createClient(options) {
   return new AAPClient(options);
 }
 
-export default { AAPClient, createClient, createSolver, verify, PROTOCOL_VERSION };
+export default { AAPClient, createClient, createSolver, verify, generateIdentity, sign, PROTOCOL_VERSION };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aap-agent-client",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "description": "WebSocket client for Agent Attestation Protocol - prove your AI agent identity",
   "main": "index.js",
   "types": "index.d.ts",