kompass-sdk 0.6.0 → 0.8.0

package/src/ranking.ts

@@ -0,0 +1,336 @@
+/**
+ * Kompass Ranking Engine
+ *
+ * Fair, cross-protocol ranking of agents/services using:
+ * 1. Source-specific reputation normalization
+ * 2. Bayesian average for cold-start protection
+ * 3. Value-for-money scoring (cost:quality ratio)
+ * 4. Geometric mean composite for final ranking
+ * 5. Wilson score for confidence-adjusted reputation
+ *
+ * Based on: npm scoring, Reddit Wilson, Twitter log-engagement,
+ * Amazon sales velocity, Airbnb market-relative pricing,
+ * IMDB Bayesian average, AgentRank (0xIntuition)
+ */
+
+import type { UnifiedAgent } from "./sources/types.js";
+
+// ── Types ────────────────────────────────────────────────
+
+export interface NormalizedReputation {
+  /** Quality signal 0-100 (success rate, reliability) */
+  quality: number;
+  /** Volume signal 0-100 (log-normalized job count, installs) */
+  volume: number;
+  /** Recency signal 0-100 (time since last active) */
+  recency: number;
+  /** Confidence 0-1 (how much evidence backs this score) */
+  confidence: number;
+}
+
+export interface RankingScores {
+  /** How well agent matches the query (0-100) */
+  relevance: number;
+  /** Bayesian-adjusted quality (0-100) */
+  quality: number;
+  /** Log-normalized usage volume (0-100) */
+  volume: number;
+  /** Time-decay recency (0-100) */
+  recency: number;
+  /** Value for money — quality relative to price (0-100) */
+  value: number;
+  /** Final composite score */
+  composite: number;
+}
+
+export interface RankedAgent {
+  agent: UnifiedAgent;
+  scores: RankingScores;
+  explanation: string;
+}
+
+// ── Configuration ────────────────────────────────────────
+
+const WEIGHTS = {
+  relevance: 0.30,
+  quality: 0.25,
+  volume: 0.15,
+  recency: 0.10,
+  value: 0.20,
+};
+
+const BAYESIAN_C = 10; // Confidence parameter for Bayesian average
+const GLOBAL_AVG_QUALITY = 50; // Prior assumption: average quality is 50/100
+
+// ── Step 1: Source-Specific Normalization ─────────────────
+
+export function normalizeReputation(agent: UnifiedAgent): NormalizedReputation {
+  const rep = agent.reputation;
+  if (!rep) return { quality: GLOBAL_AVG_QUALITY, volume: 0, recency: 50, confidence: 0 };
+
+  switch (rep.source) {
+    case "acp":
+      // successRate is 0-100%, count is completed jobs
+      return {
+        quality: rep.score,
+        volume: logNormalize(rep.count, 1000),
+        recency: recencyScore(agent.lastSeen),
+        confidence: Math.min(1, rep.count / 20), // Full confidence at 20+ jobs
+      };
+
+    case "402index":
+      // reliability_score is 0-100, count is uptime percentage (0-100)
+      return {
+        quality: rep.score,
+        volume: rep.count, // Uptime as volume proxy
+        recency: recencyScore(agent.lastSeen),
+        confidence: 0.7, // Automated monitoring = moderate confidence
+      };
+
+    case "8004scan":
+      // total_score is 0-100, count is star_count
+      return {
+        quality: rep.score,
+        volume: logNormalize(rep.count, 100),
+        recency: recencyScore(agent.lastSeen),
+        confidence: Math.min(1, rep.count / 10),
+      };
+
+    case "skills-sh-installs":
+      // Installs tell popularity, NOT quality
+      return {
+        quality: GLOBAL_AVG_QUALITY, // Unknown quality — use prior
+        volume: logNormalize(rep.count, 100000),
+        recency: 50,
+        confidence: Math.min(0.5, rep.count / 1000), // Installs give weak quality signal, cap at 0.5
+      };
+
+    case "clawhub-relevance":
+      // Search relevance, NOT reputation
+      return {
+        quality: GLOBAL_AVG_QUALITY,
+        volume: 0,
+        recency: 50,
+        confidence: 0, // Relevance says nothing about quality
+      };
+
+    default:
+      return {
+        quality: rep.score > 0 ? Math.min(rep.score, 100) : GLOBAL_AVG_QUALITY,
+        volume: logNormalize(rep.count, 100),
+        recency: recencyScore(agent.lastSeen),
+        confidence: 0.3,
+      };
+  }
+}
+
+// ── Step 2: Bayesian Average ─────────────────────────────
+
+/**
+ * Bayesian average prevents new agents with 1 job at 100%
+ * from outranking established agents with 95% over 200 jobs.
+ *
+ * Formula: (count * score + C * prior) / (count + C)
+ *
+ * Examples:
+ * - 2 jobs at 100% → 66.7 (pulls toward prior)
+ * - 200 jobs at 95% → 93.3 (mostly own data)
+ * - 0 jobs → 50.0 (pure prior)
+ */
+function bayesianQuality(normalized: NormalizedReputation): number {
+  const effectiveCount = normalized.confidence * 20; // Scale confidence to pseudo-count
+  return (effectiveCount * normalized.quality + BAYESIAN_C * GLOBAL_AVG_QUALITY) /
+    (effectiveCount + BAYESIAN_C);
+}
+
+// ── Step 3: Value Score ──────────────────────────────────
+
+/**
+ * Value = quality relative to price.
+ * A $0.01 agent with 82% success is better value than $0.25 at 76%.
+ *
+ * Free services get a moderate value score (good value but unknown quality).
+ */
+function valueScore(agent: UnifiedAgent, bayesianQ: number, allAgents: UnifiedAgent[]): number {
+  const price = parseAgentPrice(agent);
+
+  if (price === null) return 50; // Unknown price → neutral
+  if (price === 0) return Math.min(bayesianQ, 70); // Free → capped (free doesn't mean best)
+
+  // Find min price among agents with similar capabilities
+  const comparablePrices = allAgents
+    .map(parseAgentPrice)
+    .filter((p): p is number => p !== null && p > 0);
+
+  if (comparablePrices.length === 0) return 50;
+
+  const minPrice = Math.min(...comparablePrices);
+  const priceRatio = minPrice / price; // 1.0 = cheapest, <1 = more expensive
+
+  // Value = quality-adjusted price efficiency
+  // High quality + low price = high value
+  // Low quality + high price = low value
+  return Math.min(100, (bayesianQ * 0.6 + priceRatio * 100 * 0.4));
+}
+
+// ── Step 4: Geometric Mean Composite ─────────────────────
+
+/**
+ * Geometric mean ensures ALL factors must be non-zero.
+ * An agent that's free but unreliable scores zero.
+ * An agent that's perfect quality but irrelevant also scores low.
+ */
+function compositeScore(scores: Omit<RankingScores, "composite">): number {
+  const eps = 1; // Prevent zero from killing the product
+  const r = scores.relevance + eps;
+  const q = scores.quality + eps;
+  const v = scores.volume + eps;
+  const t = scores.recency + eps;
+  const p = scores.value + eps;
+
+  const totalWeight = WEIGHTS.relevance + WEIGHTS.quality + WEIGHTS.volume + WEIGHTS.recency + WEIGHTS.value;
+
+  return Math.pow(
+    Math.pow(r, WEIGHTS.relevance) *
+    Math.pow(q, WEIGHTS.quality) *
+    Math.pow(v, WEIGHTS.volume) *
+    Math.pow(t, WEIGHTS.recency) *
+    Math.pow(p, WEIGHTS.value),
+    1 / totalWeight
+  );
+}
+
+// ── Step 5: Wilson Score (Confidence-Adjusted) ───────────
+
+/**
+ * Lower bound of Wilson score confidence interval.
+ * Penalizes agents with few interactions even if success rate is high.
+ *
+ * Agent with 5/5 success → Wilson ~0.57
+ * Agent with 95/100 success → Wilson ~0.90
+ */
+export function wilsonLowerBound(positive: number, total: number, z = 1.96): number {
+  if (total === 0) return 0;
+  const phat = positive / total;
+  const denominator = 1 + z * z / total;
+  const center = phat + z * z / (2 * total);
+  const spread = z * Math.sqrt((phat * (1 - phat) + z * z / (4 * total)) / total);
+  return Math.max(0, (center - spread) / denominator);
+}
+
+// ── Main Ranking Function ────────────────────────────────
+
+/**
+ * Rank agents using the full pipeline:
+ * Normalize → Bayesian adjust → Value score → Geometric composite
+ */
+export function rankAgentsV2(
+  agents: UnifiedAgent[],
+  query: string
+): RankedAgent[] {
+  // Calculate relevance for each agent (reuse existing BM25 + structured matching)
+  const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+
+  return agents
+    .map((agent) => {
+      // Relevance (BM25-lite + structured)
+      const relevance = calculateRelevance(agent, queryTerms);
+
+      // Normalize reputation per source
+      const normalized = normalizeReputation(agent);
+
+      // Bayesian-adjusted quality
+      const quality = bayesianQuality(normalized);
+
+      // Volume
+      const volume = normalized.volume;
+
+      // Recency
+      const recency = normalized.recency;
+
+      // Value for money
+      const value = valueScore(agent, quality, agents);
+
+      const scores: RankingScores = {
+        relevance,
+        quality,
+        volume,
+        recency,
+        value,
+        composite: 0,
+      };
+
+      scores.composite = compositeScore(scores);
+
+      // Build explanation
+      const explanation = buildExplanation(agent, scores, normalized);
+
+      return { agent, scores, explanation };
+    })
+    .sort((a, b) => b.scores.composite - a.scores.composite);
+}
+
+// ── Helpers ──────────────────────────────────────────────
+
+function logNormalize(value: number, maxExpected: number): number {
+  if (value <= 0) return 0;
+  return Math.min(100, (Math.log(1 + value) / Math.log(1 + maxExpected)) * 100);
+}
+
+function recencyScore(lastSeen?: number): number {
+  if (!lastSeen) return 50; // Unknown → neutral
+  const hoursSince = (Date.now() - lastSeen) / (1000 * 60 * 60);
+  if (hoursSince < 1) return 100;
+  if (hoursSince < 24) return 80;
+  if (hoursSince < 168) return 60; // 1 week
+  if (hoursSince < 720) return 40; // 1 month
+  return 20;
+}
+
+function parseAgentPrice(agent: UnifiedAgent): number | null {
+  if (!agent.pricing?.amount) return null;
+  const amount = agent.pricing.amount;
+  if (typeof amount === "number") return amount;
+  const parsed = parseFloat(amount);
+  return isNaN(parsed) ? null : parsed;
+}
+
+function calculateRelevance(agent: UnifiedAgent, queryTerms: string[]): number {
+  const text = `${agent.name} ${agent.description} ${agent.categories.join(" ")} ${agent.capabilities.join(" ")}`.toLowerCase();
+  let score = 0;
+
+  for (const term of queryTerms) {
+    if (agent.name.toLowerCase().includes(term)) score += 15;
+    if (agent.description.toLowerCase().includes(term)) score += 8;
+    if (agent.categories.some((c) => c.includes(term))) score += 12;
+    if (agent.capabilities.some((c) => c.toLowerCase().includes(term))) score += 5;
+  }
+
+  return Math.min(100, score);
+}
+
+function buildExplanation(agent: UnifiedAgent, scores: RankingScores, normalized: NormalizedReputation): string {
+  const parts: string[] = [];
+
+  if (scores.relevance > 30) parts.push("Strong match");
+  else if (scores.relevance > 15) parts.push("Moderate match");
+  else parts.push("Weak match");
+
+  if (normalized.confidence > 0.5) {
+    if (scores.quality > 70) parts.push("proven quality");
+    else if (scores.quality > 50) parts.push("decent quality");
+    else parts.push("unproven quality");
+  } else {
+    parts.push("limited track record");
+  }
+
+  const price = parseAgentPrice(agent);
+  if (price === 0) parts.push("free");
+  else if (price !== null && price < 0.05) parts.push("very affordable");
+  else if (price !== null && price > 1) parts.push("premium priced");
+
+  if (scores.value > 70) parts.push("great value");
+  else if (scores.value < 30) parts.push("questionable value");
+
+  return parts.join(". ") + ".";
+}

package/src/sources/adp.ts

@@ -1,51 +1,55 @@
 /**
  * Agent Discovery Protocol (ADP) Source Adapter
- * agentdiscovery.io — open protocol for autonomous agent commerce
+ * Uses the real ADP v2 API at agentdiscovery.io
  */
 
 import type { SourceAdapter, UnifiedAgent, SourceSearchOptions } from "./types.js";
 
-const ADP_BASE = "https://agentdiscovery.io";
+const ADP_BASE = "https://agentdiscovery.io/api/adp/v2";
 
 export const adpAdapter: SourceAdapter = {
   name: "adp",
-  displayName: "Agent Discovery Protocol",
+  displayName: "Agent Discovery Protocol (ADP v2)",
 
   async search(query: string, options?: SourceSearchOptions): Promise<UnifiedAgent[]> {
     try {
-      // Try the ADP API
-      const res = await fetch(`${ADP_BASE}/api/agents?q=${encodeURIComponent(query)}&limit=${options?.limit ?? 20}`, {
+      // First try discovery endpoint with intent
+      const discoverRes = await fetch(`${ADP_BASE}/discover`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ intent: query, category: query }),
         signal: AbortSignal.timeout(options?.timeout ?? 5000),
       });
 
-      if (!res.ok) return [];
+      if (discoverRes.ok) {
+        const data = await discoverRes.json();
+        const agents = data.matches ?? data.agents ?? data.results ?? [];
+        if (Array.isArray(agents) && agents.length > 0) {
+          return agents.slice(0, options?.limit ?? 20).map(mapAdpAgent);
+        }
+      }
 
-      const data = await res.json();
-      const agents = Array.isArray(data) ? data : data.agents ?? data.data ?? [];
+      // Fallback: list all agents
+      const listRes = await fetch(`${ADP_BASE}/agents`, {
+        signal: AbortSignal.timeout(options?.timeout ?? 5000),
+      });
+
+      if (!listRes.ok) return [];
 
-      return agents.map((agent: any) => ({
-        id: `adp:${agent.id ?? agent.address}`,
-        nativeId: String(agent.id ?? agent.address),
-        name: agent.name ?? "ADP Agent",
-        description: agent.description ?? "",
-        categories: agent.categories ?? agent.tags ?? ["general"],
-        capabilities: agent.capabilities ?? [agent.description ?? ""],
-        source: "adp" as const,
-        protocol: (agent.protocol ?? "http") as any,
-        endpoints: {
-          http: agent.endpoint ?? agent.url,
-          a2a: agent.a2aEndpoint,
-          x402: agent.x402Endpoint,
-        },
-        reputation: agent.reputation ? {
-          score: agent.reputation.score ?? 0,
-          count: agent.reputation.count ?? 0,
-          source: "adp",
-        } : undefined,
-        pricing: agent.pricing,
-        verified: agent.verified ?? false,
-        raw: agent,
-      }));
+      const data = await listRes.json();
+      const agents = data.agents ?? [];
+      if (!Array.isArray(agents)) return [];
+
+      // Client-side filter by query
+      const lower = query.toLowerCase();
+      return agents
+        .filter((a: any) => {
+          if (!query) return true;
+          const text = `${a.name ?? ""} ${a.role ?? ""} ${(a.categories ?? []).join(" ")} ${(a.capabilities ?? []).map((c: any) => c.description ?? c.key ?? "").join(" ")}`.toLowerCase();
+          return lower.split(/\s+/).some((t) => text.includes(t));
+        })
+        .slice(0, options?.limit ?? 20)
+        .map(mapAdpAgent);
     } catch {
       return [];
     }
@@ -53,12 +57,30 @@ export const adpAdapter: SourceAdapter = {
 
   async ping(): Promise<boolean> {
     try {
-      const res = await fetch(`${ADP_BASE}/api/health`, {
-        signal: AbortSignal.timeout(3000),
-      });
+      const res = await fetch(`${ADP_BASE}/agents`, { signal: AbortSignal.timeout(3000) });
       return res.ok;
     } catch {
       return false;
     }
   },
 };
+
+function mapAdpAgent(agent: any): UnifiedAgent {
+  return {
+    id: `adp:${agent.did ?? agent.id ?? agent.name}`,
+    nativeId: agent.did ?? agent.id ?? "",
+    name: agent.name ?? "ADP Agent",
+    description: (agent.capabilities ?? []).map((c: any) => c.description ?? c.key ?? "").join(". ") || (agent.role ?? ""),
+    categories: agent.categories ?? [agent.role ?? "general"],
+    capabilities: (agent.capabilities ?? []).map((c: any) => `${c.key}: ${c.description ?? ""}`),
+    source: "adp",
+    protocol: "a2a",
+    endpoints: {
+      http: agent.endpoint ?? agent.url,
+      a2a: agent.a2a_endpoint,
+    },
+    pricing: agent.pricing,
+    verified: !!agent.did,
+    raw: agent,
+  };
+}

package/src/sources/erc8004.ts

@@ -1,107 +1,47 @@
 /**
- * ERC-8004 On-Chain Source Adapter
- * Indexes agent identities from the ERC-8004 Identity Registry on Base
+ * ERC-8004 Source Adapter
+ * Searches 8004scan.io API for registered AI agents
+ * Real data — agent identity, reputation, supported protocols
  */
 
-import { createPublicClient, http, type Address, parseAbiItem } from "viem";
-import { base, baseSepolia } from "viem/chains";
 import type { SourceAdapter, UnifiedAgent, SourceSearchOptions } from "./types.js";
 
-// ERC-8004 Identity Registry addresses
-const REGISTRY_ADDRESSES: Record<string, Address> = {
-  "base": "0x8004A818BFB912233c491871b3d84c89A494BD9e" as Address,
-  "base-sepolia": "0x8004A818BFB912233c491871b3d84c89A494BD9e" as Address,
-};
-
-const TRANSFER_EVENT = parseAbiItem(
-  "event Transfer(address indexed from, address indexed to, uint256 indexed tokenId)"
-);
-
-const TOKEN_URI_ABI = [
-  {
-    type: "function",
-    name: "tokenURI",
-    inputs: [{ name: "tokenId", type: "uint256" }],
-    outputs: [{ name: "", type: "string" }],
-    stateMutability: "view",
-  },
-] as const;
-
-export function createErc8004Adapter(network: "base" | "base-sepolia" = "base-sepolia"): SourceAdapter {
-  const chain = network === "base" ? base : baseSepolia;
-  const registryAddress = REGISTRY_ADDRESSES[network];
-
-  const client = createPublicClient({
-    chain,
-    transport: http(),
-  });
+const SCAN_API = "https://www.8004scan.io/api/v1";
 
+export function createErc8004Adapter(network: "base" | "base-sepolia" = "base"): SourceAdapter {
   return {
     name: "erc8004",
-    displayName: "ERC-8004 Identity Registry",
+    displayName: "ERC-8004 Identity Registry (8004scan)",
 
     async search(query: string, options?: SourceSearchOptions): Promise<UnifiedAgent[]> {
       const limit = options?.limit ?? 20;
+      const timeout = options?.timeout ?? 10000;
 
       try {
-        // Get recent Transfer events (minting = from 0x0)
-        const logs = await client.getLogs({
-          address: registryAddress,
-          event: TRANSFER_EVENT,
-          args: { from: "0x0000000000000000000000000000000000000000" as Address },
-          fromBlock: "earliest",
-          toBlock: "latest",
-        });
-
-        const agents: UnifiedAgent[] = [];
-
-        // Process most recent first
-        const recentLogs = logs.slice(-limit * 2).reverse();
+        // Search across all chains on 8004scan
+        const url = new URL(`${SCAN_API}/agents`);
+        if (query) url.searchParams.set("search", query);
+        url.searchParams.set("limit", String(limit));
 
-        for (const log of recentLogs) {
-          if (agents.length >= limit) break;
-
-          const tokenId = log.args.tokenId!;
-          const owner = log.args.to!;
-
-          try {
-            // Fetch tokenURI for agent metadata
-            const uri = await client.readContract({
-              address: registryAddress,
-              abi: TOKEN_URI_ABI,
-              functionName: "tokenURI",
-              args: [tokenId],
-            });
-
-            // Resolve URI to JSON
-            let metadata: any = {};
-            if (uri.startsWith("http") || uri.startsWith("ipfs")) {
-              const fetchUrl = uri.startsWith("ipfs://")
-                ? `https://ipfs.io/ipfs/${uri.slice(7)}`
-                : uri;
-              const res = await fetch(fetchUrl, { signal: AbortSignal.timeout(3000) });
-              if (res.ok) metadata = await res.json();
-            } else if (uri.startsWith("data:")) {
-              const json = uri.split(",")[1];
-              metadata = JSON.parse(atob(json));
-            }
+        const res = await fetch(url.toString(), {
+          signal: AbortSignal.timeout(timeout),
+        });
 
-            const agent = mapErc8004Agent(tokenId, owner, metadata, network);
+        if (!res.ok) return [];
 
-            // Filter by query
-            if (query) {
-              const searchText = `${agent.name} ${agent.description} ${agent.categories.join(" ")}`.toLowerCase();
-              if (!searchText.includes(query.toLowerCase())) continue;
-            }
+        const data = await res.json();
+        const agents = data.items ?? data.agents ?? data.data ?? [];
 
-            agents.push(agent);
-          } catch {
-            // Skip agents with unresolvable metadata
-            continue;
-          }
-        }
+        if (!Array.isArray(agents)) return [];
 
-        return agents;
+        return agents
+          .filter((a: any) => {
+            if (!query) return true;
+            const text = `${a.name ?? ""} ${a.description ?? ""}`.toLowerCase();
+            return query.toLowerCase().split(/\s+/).some((t) => text.includes(t));
+          })
+          .slice(0, limit)
+          .map(mapErc8004Agent);
       } catch {
         return [];
       }
@@ -109,8 +49,10 @@ export function createErc8004Adapter(network: "base" | "base-sepolia" = "base-se
 
     async ping(): Promise<boolean> {
       try {
-        await client.getBlockNumber();
-        return true;
+        const res = await fetch(`${SCAN_API}/agents?limit=1`, {
+          signal: AbortSignal.timeout(5000),
+        });
+        return res.ok;
       } catch {
         return false;
       }
@@ -118,49 +60,46 @@ export function createErc8004Adapter(network: "base" | "base-sepolia" = "base-se
   };
 }
 
-function mapErc8004Agent(
-  tokenId: bigint,
-  owner: Address,
-  metadata: any,
-  network: string
-): UnifiedAgent {
-  const services = metadata.services ?? [];
-  const endpoints: UnifiedAgent["endpoints"] = {};
+function mapErc8004Agent(agent: any): UnifiedAgent {
+  const protocols = agent.supported_protocols ?? [];
+  const protocol = protocols.includes("A2A") ? "a2a" as const
+    : protocols.includes("MCP") ? "mcp" as const
+    : protocols.includes("x402") || agent.x402_supported ? "x402" as const
+    : "onchain" as const;
 
-  for (const svc of services) {
-    if (svc.protocol === "mcp") endpoints.mcp = svc.endpoint;
-    if (svc.protocol === "a2a") endpoints.a2a = svc.endpoint;
-    if (svc.protocol === "x402") endpoints.x402 = svc.endpoint;
-    if (svc.protocol === "http") endpoints.http = svc.endpoint;
-  }
+  const endpoints: UnifiedAgent["endpoints"] = {};
+  if (protocols.includes("MCP")) endpoints.mcp = agent.mcp_endpoint;
+  if (protocols.includes("A2A")) endpoints.a2a = agent.a2a_endpoint;
+  if (agent.x402_supported) endpoints.x402 = agent.x402_endpoint;
 
   return {
-    id: `erc8004:${network}:${tokenId}`,
-    nativeId: tokenId.toString(),
-    name: metadata.name ?? `Agent #${tokenId}`,
-    description: metadata.description ?? "",
-    categories: metadata.categories ?? extractFromDescription(metadata.description ?? ""),
-    capabilities: services.map((s: any) => `${s.protocol}: ${s.endpoint}`),
+    id: `erc8004:${agent.agent_id ?? agent.token_id}`,
+    nativeId: agent.token_id?.toString() ?? agent.agent_id ?? "",
+    name: agent.name ?? `Agent #${agent.token_id}`,
+    ensName: agent.owner_ens ?? undefined,
+    description: agent.description ?? "",
+    categories: extractCategories(agent.name ?? "", agent.description ?? ""),
+    capabilities: protocols.map((p: string) => `Supports ${p}`),
     source: "erc8004",
-    protocol: endpoints.a2a ? "a2a" : endpoints.mcp ? "mcp" : endpoints.x402 ? "x402" : "onchain",
+    protocol,
     endpoints,
     reputation: {
-      score: 0,
-      count: 0,
-      source: "erc8004",
+      score: agent.total_score ?? 0,
+      count: agent.star_count ?? 0,
+      source: "8004scan",
     },
-    verified: true,
-    lastSeen: Date.now(),
-    raw: { tokenId: tokenId.toString(), owner, metadata, network },
+    verified: agent.is_verified ?? false,
+    raw: agent,
   };
 }
 
-function extractFromDescription(text: string): string[] {
-  const lower = text.toLowerCase();
+function extractCategories(name: string, description: string): string[] {
+  const text = `${name} ${description}`.toLowerCase();
   const cats: string[] = [];
-  if (lower.match(/defi|yield|swap|pool/)) cats.push("defi");
-  if (lower.match(/data|analyt/)) cats.push("data");
-  if (lower.match(/trade|trading/)) cats.push("trading");
-  if (lower.match(/research/)) cats.push("research");
+  if (text.match(/defi|yield|swap|pool|trading/)) cats.push("defi");
+  if (text.match(/data|analyt|research/)) cats.push("data");
+  if (text.match(/code|develop|build/)) cats.push("development");
+  if (text.match(/ai|model|inference/)) cats.push("ai");
+  if (text.match(/security|audit/)) cats.push("security");
   return cats.length > 0 ? cats : ["general"];
 }