aap-agent-client 2.7.0 → 3.0.0

package/index.js

@@ -1,214 +1,146 @@
 /**
- * @aap/client
+ * @aap/client v3.0.0
  * 
- * Client library for Agent Attestation Protocol.
- * Enables AI agents to prove their identity to verification servers.
+ * WebSocket client for Agent Attestation Protocol.
+ * Connect, solve sequential challenges, prove your intelligence.
  */
 
-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);
-  }
-}
+import WebSocket from 'ws';
+
+export const PROTOCOL_VERSION = '3.0.0';
 
 /**
- * AAP Client - High-level interface for verification
+ * AAP WebSocket Client
  */
 export class AAPClient {
-  /**
-   * @param {Object} [options]
-   * @param {string} [options.serverUrl] - Default verification server URL
-   * @param {string} [options.storagePath] - Identity storage path
-   * @param {Function} [options.llmCallback] - Default LLM callback for solutions
-   */
   constructor(options = {}) {
-    this.serverUrl = options.serverUrl?.replace(/\/$/, '');
-    this.llmCallback = options.llmCallback;
-    this.prover = new Prover({ storagePath: options.storagePath });
+    this.serverUrl = options.serverUrl || 'ws://localhost:3000/aap';
+    this.publicId = options.publicId || null;
+    this.solver = options.solver || null;
   }
 
   /**
-   * Get agent's public identity
-   * @returns {Object}
-   */
-  getIdentity() {
-    return this.prover.getIdentity();
-  }
-
-  /**
-   * Perform full verification against a server
-   * 
-   * @param {string} [serverUrl] - Override default server URL
-   * @param {Function|string} [solutionOrCallback] - Solution or LLM callback
+   * Connect and verify
+   * @param {Function} [solver] - async (challengeString, challengeId) => answerObject
    * @returns {Promise<Object>} Verification result
    */
-  async verify(serverUrl, solutionOrCallback) {
-    const baseUrl = (serverUrl || this.serverUrl)?.replace(/\/$/, '');
-    if (!baseUrl) {
-      throw new Error('Server URL is required');
-    }
-
-    const callback = solutionOrCallback || this.llmCallback;
-
-    // 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}`);
-    }
-
-    const challenge = await challengeRes.json();
-
-    // Step 2: Generate proof
-    const proof = await this.prover.generateProof(challenge, callback);
-
-    // 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();
-
-    return {
-      ...result,
-      challenge,
-      proof: {
-        solution: proof.solution,
-        responseTimeMs: proof.responseTimeMs,
-        publicId: proof.publicId
-      }
-    };
-  }
-
-  /**
-   * Check server health
-   * @param {string} [serverUrl] - Override default server URL
-   * @returns {Promise<Object>}
-   */
-  async checkHealth(serverUrl) {
-    const baseUrl = (serverUrl || this.serverUrl)?.replace(/\/$/, '');
-    if (!baseUrl) {
-      throw new Error('Server URL is required');
-    }
-
-    try {
-      const res = await fetch(`${baseUrl}/health`);
-      if (!res.ok) {
-        return { healthy: false, error: `HTTP ${res.status}` };
-      }
-      return { healthy: true, ...(await res.json()) };
-    } catch (error) {
-      return { healthy: false, error: error.message };
-    }
-  }
-
-  /**
-   * Get a challenge without verifying (for manual flow)
-   * @param {string} [serverUrl] - Override default server URL
-   * @returns {Promise<Object>}
-   */
-  async getChallenge(serverUrl) {
-    const baseUrl = (serverUrl || this.serverUrl)?.replace(/\/$/, '');
-    if (!baseUrl) {
-      throw new Error('Server URL is required');
-    }
-
-    const res = await fetch(`${baseUrl}/challenge`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' }
+  async verify(solver) {
+    const solve = solver || this.solver;
+    
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(this.serverUrl);
+      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':
+              // Send ready
+              ws.send(JSON.stringify({
+                type: 'ready',
+                publicId: this.publicId
+              }));
+              break;
+
+            case 'challenge':
+              if (!solve) {
+                // No solver - send empty answer (will fail)
+                ws.send(JSON.stringify({ type: 'answer', answer: {} }));
+                break;
+              }
+
+              try {
+                const answer = await solve(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, waiting for next
+              break;
+
+            case 'timeout':
+              // Too slow
+              break;
+
+            case 'result':
+              result = msg;
+              break;
+
+            case 'error':
+              reject(new Error(msg.message || 'Unknown error'));
+              ws.close();
+              break;
+          }
+        } catch (e) {
+          reject(e);
+          ws.close();
+        }
+      });
+
+      ws.on('close', () => {
+        if (result) {
+          resolve(result);
+        } else {
+          reject(new Error('Connection closed without result'));
+        }
+      });
+
+      ws.on('error', (err) => {
+        reject(err);
+      });
     });
-
-    if (!res.ok) {
-      throw new Error(`Failed to get challenge: ${res.status}`);
-    }
-
-    return res.json();
-  }
-
-  /**
-   * Generate a proof for a challenge (for manual flow)
-   * @param {Object} challenge - Challenge from getChallenge()
-   * @param {Function|string} [solutionOrCallback] - Solution or callback
-   * @returns {Promise<Object>}
-   */
-  async generateProof(challenge, solutionOrCallback) {
-    return this.prover.generateProof(challenge, solutionOrCallback || this.llmCallback);
   }
+}
 
-  /**
-   * Submit a proof for verification (for manual flow)
-   * @param {string} serverUrl - Server URL
-   * @param {Object} proof - Proof from generateProof()
-   * @returns {Promise<Object>}
-   */
-  async submitProof(serverUrl, proof) {
-    const baseUrl = (serverUrl || this.serverUrl)?.replace(/\/$/, '');
-    if (!baseUrl) {
-      throw new Error('Server URL is required');
+/**
+ * Create a solver function from an LLM callback
+ * @param {Function} llm - async (prompt) => responseString
+ * @returns {Function} Solver function for verify()
+ */
+export function createSolver(llm) {
+  return async (challengeString, challengeId) => {
+    const prompt = `Solve this challenge. Respond with ONLY the JSON object, no explanation:
+
+${challengeString}`;
+
+    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');
     }
+    
+    return JSON.parse(match[0]);
+  };
+}
 
-    const res = await fetch(`${baseUrl}/verify`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify(proof)
-    });
-
-    return res.json();
-  }
-
-  /**
-   * Sign arbitrary data
-   * @param {string} data - Data to sign
-   * @returns {Object}
-   */
-  sign(data) {
-    return this.prover.sign(data);
-  }
+/**
+ * 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 });
+  return client.verify();
 }
 
-// Convenience factory
+/**
+ * Create client instance
+ */
 export function createClient(options) {
   return new AAPClient(options);
 }
 
-// Re-export Prover
-export { Prover };
-
-// WebSocket client (v2.7+)
-export { AAPWebSocketClient, createSolver, verifyWithWebSocket } from './websocket.js';
-
-export default { AAPClient, createClient, Prover };
+export default { AAPClient, createClient, createSolver, verify, PROTOCOL_VERSION };

package/package.json

@@ -1,16 +1,15 @@
 {
   "name": "aap-agent-client",
-  "version": "2.7.0",
-  "description": "Client library for Agent Attestation Protocol - prove your AI agent identity",
+  "version": "3.0.0",
+  "description": "WebSocket client for Agent Attestation Protocol - prove your AI agent identity",
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",
   "exports": {
-    ".": "./index.js",
-    "./prover": "./prover.js"
+    ".": "./index.js"
   },
   "files": ["*.js", "README.md"],
-  "keywords": ["aap", "agent", "attestation", "client", "ai", "verification", "llm"],
+  "keywords": ["aap", "agent", "attestation", "client", "ai", "verification", "websocket"],
   "author": "ira-hash",
   "license": "MIT",
   "repository": {
@@ -20,7 +19,6 @@
   },
   "homepage": "https://github.com/ira-hash/agent-attestation-protocol#readme",
   "dependencies": {
-    "aap-agent-core": "^2.6.0",
     "ws": "^8.16.0"
   },
   "engines": {

package/prover.js

@@ -1,391 +0,0 @@
-/**
- * @aap/client - Prover
- * 
- * Generates proofs for AAP verification (supports batch challenges).
- */
-
-import { createHash } from 'node:crypto';
-import { Identity, createProofData } from 'aap-agent-core';
-
-/**
- * Prover class for generating AAP proofs
- */
-export class Prover {
-  /**
-   * @param {Object} [options]
-   * @param {Identity} [options.identity] - Pre-existing identity instance
-   * @param {string} [options.storagePath] - Path for identity storage
-   */
-  constructor(options = {}) {
-    this.identity = options.identity || new Identity({ storagePath: options.storagePath });
-    this.identity.init();
-  }
-
-  /**
-   * Get public identity info
-   * @returns {Object}
-   */
-  getIdentity() {
-    return this.identity.getPublic();
-  }
-
-  /**
-   * Generate proofs for a batch of challenges
-   * 
-   * @param {Object} challengeBatch - Batch challenge from server
-   * @param {string} challengeBatch.nonce - Server-provided nonce
-   * @param {Array} challengeBatch.challenges - Array of challenges
-   * @param {Function|null} [llmCallback] - Async LLM callback for solving
-   * @returns {Promise<Object>} Proof object ready for submission
-   */
-  async generateBatchProof(challengeBatch, llmCallback) {
-    const startTime = Date.now();
-    const { nonce, challenges } = challengeBatch;
-
-    // Solve all challenges
-    const solutions = [];
-    
-    if (llmCallback) {
-      // Use LLM to solve all at once (more efficient)
-      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) {
-        const solution = this.solve(challenge.challenge_string, nonce, challenge.type);
-        solutions.push(solution);
-      }
-    }
-
-    // Create proof
-    const identity = this.identity.getPublic();
-    const timestamp = Date.now();
-    
-    const solutionsString = JSON.stringify(solutions);
-    const proofData = createProofData({
-      nonce,
-      solution: solutionsString,
-      publicId: identity.publicId,
-      timestamp
-    });
-
-    const signature = this.identity.sign(proofData);
-    const responseTimeMs = Date.now() - startTime;
-
-    return {
-      solutions,
-      signature,
-      publicKey: identity.publicKey,
-      publicId: identity.publicId,
-      nonce,
-      timestamp,
-      responseTimeMs,
-      protocol: 'AAP',
-      version: '2.0.0'
-    };
-  }
-
-  /**
-   * Create a combined prompt for batch solving
-   * @private
-   */
-  createBatchPrompt(challenges) {
-    let prompt = `Solve all of the following challenges. Respond with a JSON array of solutions.\n\n`;
-    
-    challenges.forEach((c, i) => {
-      prompt += `Challenge ${i + 1} (${c.type}):\n${c.challenge_string}\n\n`;
-    });
-    
-    prompt += `\nRespond with ONLY a JSON array like: [{"result": ...}, {"items": [...]}, {"answer": "..."}]`;
-    
-    return prompt;
-  }
-
-  /**
-   * Parse LLM response into solutions array
-   * @private
-   */
-  parseBatchResponse(response, expectedCount) {
-    try {
-      // Try to find JSON array in response
-      const match = response.match(/\[[\s\S]*\]/);
-      if (match) {
-        const parsed = JSON.parse(match[0]);
-        if (Array.isArray(parsed) && parsed.length === expectedCount) {
-          return parsed.map(s => typeof s === 'string' ? s : JSON.stringify(s));
-        }
-      }
-    } catch (e) {
-      // Fall through to fallback
-    }
-    
-    // Fallback: try to extract individual JSON objects
-    const solutions = [];
-    const jsonMatches = response.matchAll(/\{[^{}]*\}/g);
-    for (const match of jsonMatches) {
-      solutions.push(match[0]);
-      if (solutions.length >= expectedCount) break;
-    }
-    
-    // Pad with empty if needed
-    while (solutions.length < expectedCount) {
-      solutions.push('{}');
-    }
-    
-    return solutions;
-  }
-
-  /**
-   * Generate a proof for a single challenge (legacy)
-   */
-  async generateProof(challenge, solutionOrCallback) {
-    const startTime = Date.now();
-    const { challenge_string, nonce, type } = challenge;
-
-    let solution;
-    if (typeof solutionOrCallback === 'function') {
-      solution = await solutionOrCallback(challenge_string, nonce, type);
-    } else if (typeof solutionOrCallback === 'string') {
-      solution = solutionOrCallback;
-    } else {
-      solution = this.solve(challenge_string, nonce, type);
-    }
-
-    const identity = this.identity.getPublic();
-    const timestamp = Date.now();
-    
-    const proofData = createProofData({
-      nonce,
-      solution,
-      publicId: identity.publicId,
-      timestamp
-    });
-
-    const signature = this.identity.sign(proofData);
-    const responseTimeMs = Date.now() - startTime;
-
-    return {
-      solution,
-      signature,
-      publicKey: identity.publicKey,
-      publicId: identity.publicId,
-      nonce,
-      timestamp,
-      responseTimeMs,
-      protocol: 'AAP',
-      version: '2.0.0'
-    };
-  }
-
-  /**
-   * Solve a challenge programmatically
-   */
-  solve(challengeString, nonce, type) {
-    const solvers = {
-      nlp_math: () => {
-        // "Subtract B from A, then multiply by C"
-        let match = challengeString.match(/Subtract (\d+) from (\d+), then multiply.*?(\d+)/i);
-        if (match) {
-          const result = (parseInt(match[2]) - parseInt(match[1])) * parseInt(match[3]);
-          return JSON.stringify({ result });
-        }
-        // "Add A and B together, then divide by C"
-        match = challengeString.match(/Add (\d+) and (\d+).*?divide by (\d+)/i);
-        if (match) {
-          const result = Math.round(((parseInt(match[1]) + parseInt(match[2])) / parseInt(match[3])) * 100) / 100;
-          return JSON.stringify({ result });
-        }
-        // "Divide A by C, then add B"
-        match = challengeString.match(/Divide (\d+) by (\d+), then add (\d+)/i);
-        if (match) {
-          const result = Math.round((parseInt(match[1]) / parseInt(match[2]) + parseInt(match[3])) * 100) / 100;
-          return JSON.stringify({ result });
-        }
-        return JSON.stringify({ result: 0 });
-      },
-
-      nlp_extract: () => {
-        // Extract items from quoted sentence
-        const sentenceMatch = challengeString.match(/Sentence: "([^"]+)"/);
-        if (!sentenceMatch) return JSON.stringify({ items: [] });
-        
-        const sentence = sentenceMatch[1].toLowerCase();
-        
-        const animals = ['cat', 'dog', 'rabbit', 'tiger', 'lion', 'elephant', 'giraffe', 'penguin', 'eagle', 'shark'];
-        const fruits = ['apple', 'banana', 'orange', 'grape', 'strawberry', 'watermelon', 'peach', 'kiwi', 'mango', 'cherry'];
-        const colors = ['red', 'blue', 'yellow', 'green', 'purple', 'orange', 'pink', 'black', 'white', 'brown'];
-        
-        let pool = animals;
-        if (challengeString.toLowerCase().includes('fruit')) pool = fruits;
-        if (challengeString.toLowerCase().includes('color')) pool = colors;
-        
-        const found = pool.filter(item => sentence.includes(item.toLowerCase()));
-        return JSON.stringify({ items: found });
-      },
-
-      nlp_transform: () => {
-        const inputMatch = challengeString.match(/"([^"]+)"/);
-        if (!inputMatch) return JSON.stringify({ output: '' });
-        const input = inputMatch[1];
-        
-        if (challengeString.toLowerCase().includes('reverse') && challengeString.toLowerCase().includes('uppercase')) {
-          return JSON.stringify({ output: input.split('').reverse().join('').toUpperCase() });
-        }
-        if (challengeString.toLowerCase().includes('digits') && challengeString.toLowerCase().includes('sum')) {
-          const sum = input.split('').filter(c => /\d/.test(c)).reduce((a, b) => a + parseInt(b), 0);
-          return JSON.stringify({ output: sum });
-        }
-        if (challengeString.toLowerCase().includes('letters') && challengeString.toLowerCase().includes('sort')) {
-          const sorted = input.split('').filter(c => /[a-zA-Z]/.test(c)).sort().join('');
-          return JSON.stringify({ output: sorted });
-        }
-        if (challengeString.toLowerCase().includes('hyphen')) {
-          return JSON.stringify({ output: input.split('').join('-') });
-        }
-        return JSON.stringify({ output: input });
-      },
-
-      nlp_logic: () => {
-        // "If the larger number between A and B is greater than C"
-        let match = challengeString.match(/larger.*?between (\d+) and (\d+).*?greater than (\d+).*?"(\w+)".*?"(\w+)"/i);
-        if (match) {
-          const answer = Math.max(parseInt(match[1]), parseInt(match[2])) > parseInt(match[3]) ? match[4] : match[5];
-          return JSON.stringify({ answer });
-        }
-        // "If the sum of A and B is less than C"
-        match = challengeString.match(/sum of (\d+) and (\d+).*?less than (\d+).*?"(\w+)".*?"(\w+)"/i);
-        if (match) {
-          const answer = (parseInt(match[1]) + parseInt(match[2])) < parseInt(match[3]) ? match[4] : match[5];
-          return JSON.stringify({ answer });
-        }
-        // "If A is even and B is odd"
-        match = challengeString.match(/If (\d+) is even and (\d+) is odd.*?"(\w+)".*?"(\w+)"/i);
-        if (match) {
-          const answer = (parseInt(match[1]) % 2 === 0 && parseInt(match[2]) % 2 === 1) ? match[3] : match[4];
-          return JSON.stringify({ answer });
-        }
-        return JSON.stringify({ answer: "NO" });
-      },
-
-      nlp_count: () => {
-        const sentenceMatch = challengeString.match(/Sentence: "([^"]+)"/);
-        if (!sentenceMatch) return JSON.stringify({ count: 0 });
-        
-        const sentence = sentenceMatch[1].toLowerCase();
-        
-        const animals = ['cat', 'dog', 'rabbit', 'tiger', 'lion', 'elephant', 'giraffe', 'penguin', 'eagle', 'shark'];
-        const fruits = ['apple', 'banana', 'orange', 'grape', 'strawberry', 'watermelon', 'peach', 'kiwi', 'mango', 'cherry'];
-        const colors = ['red', 'blue', 'yellow', 'green', 'purple', 'orange', 'pink', 'black', 'white', 'brown'];
-        
-        let pool = animals;
-        if (challengeString.toLowerCase().includes('fruit')) pool = fruits;
-        if (challengeString.toLowerCase().includes('color')) pool = colors;
-        
-        const count = pool.filter(item => sentence.includes(item.toLowerCase())).length;
-        return JSON.stringify({ count });
-      },
-
-      nlp_multistep: () => {
-        const numbersMatch = challengeString.match(/\[([^\]]+)\]/);
-        if (!numbersMatch) return JSON.stringify({ result: 0 });
-        
-        const numbers = numbersMatch[1].split(',').map(n => parseInt(n.trim()));
-        const sum = numbers.reduce((a, b) => a + b, 0);
-        const min = Math.min(...numbers);
-        const max = Math.max(...numbers);
-        const result = sum * min - max;
-        
-        return JSON.stringify({ result });
-      },
-
-      nlp_pattern: () => {
-        const match = challengeString.match(/\[([^\]]+)\]/);
-        if (!match) return JSON.stringify({ next: [0, 0] });
-        
-        const nums = match[1].split(',').map(n => parseInt(n.trim())).filter(n => !isNaN(n));
-        if (nums.length < 2) return JSON.stringify({ next: [0, 0] });
-        
-        // Try arithmetic
-        const diff = nums[1] - nums[0];
-        const isArithmetic = nums.every((n, i) => i === 0 || n - nums[i-1] === diff);
-        if (isArithmetic) {
-          const last = nums[nums.length - 1];
-          return JSON.stringify({ next: [last + diff, last + diff * 2] });
-        }
-        
-        // Try geometric (doubling)
-        const ratio = nums[1] / nums[0];
-        const isGeometric = nums.every((n, i) => i === 0 || n / nums[i-1] === ratio);
-        if (isGeometric && ratio === 2) {
-          const last = nums[nums.length - 1];
-          return JSON.stringify({ next: [last * 2, last * 4] });
-        }
-        
-        // Try Fibonacci-like
-        const isFib = nums.length >= 3 && nums.slice(2).every((n, i) => n === nums[i] + nums[i+1]);
-        if (isFib) {
-          const n1 = nums[nums.length - 2] + nums[nums.length - 1];
-          const n2 = nums[nums.length - 1] + n1;
-          return JSON.stringify({ next: [n1, n2] });
-        }
-        
-        return JSON.stringify({ next: [0, 0] });
-      },
-
-      nlp_analysis: () => {
-        const listMatch = challengeString.match(/list: ([^\.]+)/i);
-        if (!listMatch) return JSON.stringify({ answer: '' });
-        
-        const words = listMatch[1].split(',').map(w => w.trim().toLowerCase());
-        
-        if (challengeString.toLowerCase().includes('longest')) {
-          const longest = words.reduce((a, b) => a.length >= b.length ? a : b);
-          return JSON.stringify({ answer: longest });
-        }
-        if (challengeString.toLowerCase().includes('shortest')) {
-          const shortest = words.reduce((a, b) => a.length <= b.length ? a : b);
-          return JSON.stringify({ answer: shortest });
-        }
-        if (challengeString.toLowerCase().includes('alphabetically')) {
-          const first = [...words].sort()[0];
-          return JSON.stringify({ answer: first });
-        }
-        
-        return JSON.stringify({ answer: words[0] || '' });
-      }
-    };
-
-    const solver = solvers[type];
-    if (solver) {
-      return solver();
-    }
-
-    return JSON.stringify({ error: `Unknown type: ${type}` });
-  }
-
-  /**
-   * Sign arbitrary data
-   */
-  sign(data) {
-    return {
-      data,
-      signature: this.identity.sign(data),
-      publicId: this.identity.getPublic().publicId,
-      timestamp: Date.now()
-    };
-  }
-}
-
-export default { Prover };

package/websocket.js

@@ -1,162 +0,0 @@
-/**
- * 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;