kompass-sdk 0.13.0 → 0.15.0

package/src/sources/mcp-registry.ts

@@ -1,7 +1,7 @@
 /**
  * MCP Registry Source Adapter
- * Crawls registry.modelcontextprotocol.io for MCP servers
- * No auth required. Public REST API with cursor pagination.
+ * Fetches servers from registry.modelcontextprotocol.io
+ * Uses local cache + text search against descriptions (not just names)
  */
 
 import type { SourceAdapter, UnifiedAgent, SourceSearchOptions } from "./types.js";
@@ -13,9 +13,83 @@ interface McpServer {
   description?: string;
   version?: string;
   repo?: string;
+  repository?: { url?: string };
+  websiteUrl?: string;
   website?: string;
-  packages?: { registry: string; name: string }[];
-  remotes?: { transport: string; url: string }[];
+  remotes?: { type: string; url: string; headers?: { name: string; isRequired?: boolean }[] }[];
+}
+
+// In-memory cache of all servers — fetched once, reused
+let serverCache: McpServer[] | null = null;
+let cacheTime = 0;
+const CACHE_TTL = 10 * 60 * 1000; // 10 minutes
+
+async function fetchAllServers(timeout: number): Promise<McpServer[]> {
+  // Return cache if fresh
+  if (serverCache && Date.now() - cacheTime < CACHE_TTL) {
+    return serverCache;
+  }
+
+  const allServers: McpServer[] = [];
+  let cursor: string | undefined;
+
+  // Paginate through all servers (max 3 pages of 96)
+  for (let page = 0; page < 3; page++) {
+    const url = new URL("/v0.1/servers", BASE_URL);
+    url.searchParams.set("limit", "96");
+    url.searchParams.set("version", "latest");
+    if (cursor) url.searchParams.set("cursor", cursor);
+
+    const res = await fetch(url.toString(), { signal: AbortSignal.timeout(timeout) });
+    if (!res.ok) break;
+
+    const data = await res.json();
+    const servers = (data.servers ?? []).map((item: any) => item.server ?? item);
+    allServers.push(...servers);
+
+    cursor = data.metadata?.nextCursor ?? data.nextCursor;
+    if (!cursor) break;
+  }
+
+  serverCache = allServers;
+  cacheTime = Date.now();
+  return allServers;
+}
+
+/**
+ * Search servers locally by matching query against name + description.
+ * Much better than the registry's keyword search which only matches names.
+ */
+function searchLocally(servers: McpServer[], query: string, limit: number): McpServer[] {
+  const queryTerms = query.toLowerCase().split(/\s+/).filter((t) => t.length > 2);
+
+  return servers
+    .map((server) => {
+      const text = `${server.name} ${server.description ?? ""}`.toLowerCase();
+      let score = 0;
+
+      for (const term of queryTerms) {
+        // Exact word match in description
+        if (text.includes(term)) score += 3;
+        // Name match is stronger
+        if (server.name.toLowerCase().includes(term)) score += 5;
+      }
+
+      // Bonus for having remote endpoints (actually callable)
+      if (server.remotes && server.remotes.length > 0) score += 2;
+
+      // Bonus for no auth required
+      const noAuth = server.remotes?.some((r) =>
+        !r.headers?.some((h) => h.isRequired && h.name.toLowerCase() === "authorization")
+      );
+      if (noAuth) score += 1;
+
+      return { server, score };
+    })
+    .filter((s) => s.score > 0)
+    .sort((a, b) => b.score - a.score)
+    .slice(0, limit)
+    .map((s) => s.server);
 }
 
 export const mcpRegistryAdapter: SourceAdapter = {
@@ -23,47 +97,30 @@ export const mcpRegistryAdapter: SourceAdapter = {
   displayName: "MCP Registry (Anthropic)",
 
   async search(query: string, options?: SourceSearchOptions): Promise<UnifiedAgent[]> {
-    const limit = options?.limit ?? 50;
-    const timeout = options?.timeout ?? 10000;
-
-    // MCP Registry uses keyword search, not semantic.
-    // Expand user intent into multiple keyword searches to improve recall.
-    const searchTerms = expandQueryToKeywords(query);
-    const allServers: McpServer[] = [];
-    const seenNames = new Set<string>();
+    const limit = options?.limit ?? 20;
+    const timeout = options?.timeout ?? 15000;
 
     try {
-      // Run searches in parallel for speed (max 3 terms)
-      const results = await Promise.allSettled(
-        searchTerms.slice(0, 3).map(async (term) => {
-          const url = new URL("/v0.1/servers", BASE_URL);
-          url.searchParams.set("limit", String(Math.min(limit, 20)));
-          url.searchParams.set("search", term);
-          url.searchParams.set("version", "latest");
-
-          const res = await fetch(url.toString(), { signal: AbortSignal.timeout(timeout) });
-          if (!res.ok) return [];
-
-          const data = await res.json();
-          const rawServers = data.servers ?? data.data ?? [];
-          return rawServers.map((item: any) => item.server ?? item) as McpServer[];
-        })
-      );
-
-      for (const result of results) {
-        if (result.status === "fulfilled") {
-          for (const server of result.value) {
-            if (!seenNames.has(server.name)) {
-              seenNames.add(server.name);
-              allServers.push(server);
-            }
-          }
-        }
-      }
-
-      return allServers.slice(0, limit).map((server) => mapMcpServer(server));
+      const allServers = await fetchAllServers(timeout);
+      const matched = searchLocally(allServers, query, limit);
+      return matched.map(mapMcpServer);
     } catch {
-      return [];
+      // Fallback to direct API search if cache fetch fails
+      try {
+        const url = new URL("/v0.1/servers", BASE_URL);
+        url.searchParams.set("limit", String(limit));
+        if (query) url.searchParams.set("search", query.split(/\s+/)[0]); // Single word fallback
+        url.searchParams.set("version", "latest");
+
+        const res = await fetch(url.toString(), { signal: AbortSignal.timeout(timeout) });
+        if (!res.ok) return [];
+
+        const data = await res.json();
+        const servers = (data.servers ?? []).map((item: any) => item.server ?? item);
+        return servers.slice(0, limit).map(mapMcpServer);
+      } catch {
+        return [];
+      }
     }
   },
 
@@ -80,7 +137,10 @@ export const mcpRegistryAdapter: SourceAdapter = {
 };
 
 function mapMcpServer(server: McpServer): UnifiedAgent {
-  const remoteUrl = server.remotes?.[0]?.url;
+  const remote = server.remotes?.find((r) =>
+    !r.headers?.some((h) => h.isRequired && h.name.toLowerCase() === "authorization")
+  ) ?? server.remotes?.[0];
+
   const categories = extractCategories(server.description ?? server.name);
 
   return {
@@ -93,68 +153,15 @@ function mapMcpServer(server: McpServer): UnifiedAgent {
     source: "mcp-registry",
     protocol: "mcp",
     endpoints: {
-      mcp: remoteUrl,
-      http: server.website ?? server.repo,
+      mcp: remote?.url,
+      http: server.websiteUrl ?? server.website ?? (server.repository as any)?.url ?? server.repo,
     },
     pricing: { model: "free" },
-    verified: !!server.repo,
+    verified: !!remote,
     raw: server,
   };
 }
 
-/**
- * Expand natural language query into MCP Registry keyword searches.
- * "search the web for DeFi news" → ["web search", "exa", "DeFi", "news"]
- * "query postgres database" → ["postgres", "database", "sql"]
- */
-function expandQueryToKeywords(query: string): string[] {
-  const terms: string[] = [];
-  const lower = query.toLowerCase();
-
-  // Always include the raw query words (2+ chars)
-  const words = lower.split(/\s+/).filter((w) => w.length > 2);
-  terms.push(...words.slice(0, 3));
-
-  // Intent → tool name mappings (what users say → what MCP servers are called)
-  const expansions: Record<string, string[]> = {
-    "search": ["exa", "web search", "tavily", "search"],
-    "web": ["exa", "web", "browser", "scrape"],
-    "scrape": ["scrape", "crawl", "browser", "firecrawl"],
-    "database": ["postgres", "mysql", "sqlite", "database", "sql"],
-    "sql": ["postgres", "mysql", "sql", "database"],
-    "postgres": ["postgres"],
-    "weather": ["weather"],
-    "email": ["email", "gmail", "mail"],
-    "github": ["github", "git"],
-    "slack": ["slack"],
-    "file": ["file", "filesystem", "s3"],
-    "image": ["image", "dalle", "vision"],
-    "code": ["code", "github", "lint"],
-    "defi": ["defi", "exa", "blockchain"],
-    "crypto": ["crypto", "blockchain", "exa"],
-    "news": ["news", "exa", "search"],
-    "data": ["data", "analytics"],
-    "deploy": ["deploy", "vercel", "aws"],
-    "document": ["document", "pdf", "markdown"],
-    "translate": ["translate", "language"],
-    "calendar": ["calendar", "google"],
-    "map": ["map", "location", "geo"],
-    "payment": ["payment", "stripe"],
-    "ai": ["openai", "anthropic", "ai"],
-    "research": ["exa", "search", "research"],
-    "analyze": ["analytics", "data", "chart"],
-  };
-
-  for (const word of words) {
-    if (expansions[word]) {
-      terms.push(...expansions[word]);
-    }
-  }
-
-  // Deduplicate
-  return [...new Set(terms)];
-}
-
 function extractCategories(text: string): string[] {
   const lower = text.toLowerCase();
   const cats: string[] = [];
@@ -165,6 +172,8 @@ function extractCategories(text: string): string[] {
     file: "tools", browser: "tools", web: "tools",
     ai: "ai", llm: "ai", model: "ai",
     image: "media", video: "media", audio: "media",
+    trading: "trading", market: "trading", price: "trading",
+    email: "communication", slack: "communication", chat: "communication",
   };
   for (const [keyword, cat] of Object.entries(keywords)) {
     if (lower.includes(keyword) && !cats.includes(cat)) cats.push(cat);

package/src/sources/types.ts

@@ -14,7 +14,9 @@ export type AgentSource =
   | "adp"
   | "a2a-wellknown"
   | "l402-directory"
-  | "skills-registry";
+  | "skills-registry"
+  | "bankr"
+  | "locus";
 
 export type AgentProtocol = "acp" | "mcp" | "x402" | "a2a" | "http" | "l402" | "onchain" | "skill";
 

package/src/wallet/bridge.ts

@@ -19,6 +19,10 @@ const USDC_ADDRESSES: Record<string, Address> = {
   "base-sepolia": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
 };
 
+// Kompass treasury address — receives platform fee on payments
+const KOMPASS_TREASURY: Address = "0x2aB73f8CCee4ABE601cE71eCC82Bd9eC375FeBbA";
+const PLATFORM_FEE_BPS = 200; // 2% = 200 basis points
+
 // ── ACP Wallet Topup ─────────────────────────────────────
 
 /**
@@ -29,12 +33,17 @@ export async function topupACPWallet(
   wallet: KompassWallet,
   acpWalletAddress: Address,
   amountUSDC: number
-): Promise<{ txHash: Hex; amount: string }> {
+): Promise<{ txHash: Hex; amount: string; fee?: string }> {
   const network = wallet.getNetwork();
   const usdcAddress = USDC_ADDRESSES[network];
   if (!usdcAddress) throw new Error(`No USDC address for network: ${network}`);
 
-  const amount = parseUnits(String(amountUSDC), 6);
+  // Calculate platform fee (2%)
+  const feeUSDC = amountUSDC * PLATFORM_FEE_BPS / 10000;
+  const netAmount = amountUSDC - feeUSDC;
+  const totalNeeded = parseUnits(String(amountUSDC), 6);
+  const netAmountRaw = parseUnits(String(netAmount.toFixed(6)), 6);
+  const feeAmountRaw = totalNeeded - netAmountRaw;
 
   // Check balance first
   const balance = await wallet.getPublicClient().readContract({
@@ -44,25 +53,43 @@ export async function topupACPWallet(
     args: [wallet.getAddress()],
   });
 
-  if (balance < amount) {
+  if (balance < totalNeeded) {
     throw new Error(
       `Insufficient USDC: have ${formatUnits(balance, 6)}, need ${amountUSDC}. ` +
       `Fund your Kompass wallet at ${wallet.getAddress()} on ${network}.`
     );
   }
 
+  // Transfer net amount to ACP wallet
   const txHash = await (wallet.getWalletClient() as any).writeContract({
     address: usdcAddress,
     abi: USDC_ABI,
     functionName: "transfer",
-    args: [acpWalletAddress, amount],
+    args: [acpWalletAddress, netAmountRaw],
   });
 
   await wallet.getPublicClient().waitForTransactionReceipt({ hash: txHash });
 
-  console.log(`[Kompass Bridge] Transferred ${amountUSDC} USDC to ACP wallet ${acpWalletAddress.slice(0, 10)}... | tx: ${txHash}`);
+  // Transfer platform fee to Kompass treasury (skip if treasury == ACP wallet)
+  if (feeAmountRaw > 0n && KOMPASS_TREASURY.toLowerCase() !== acpWalletAddress.toLowerCase()) {
+    try {
+      const feeTx = await (wallet.getWalletClient() as any).writeContract({
+        address: usdcAddress,
+        abi: USDC_ABI,
+        functionName: "transfer",
+        args: [KOMPASS_TREASURY, feeAmountRaw],
+      });
+      await wallet.getPublicClient().waitForTransactionReceipt({ hash: feeTx });
+      console.log(`[Kompass Bridge] Platform fee: $${feeUSDC.toFixed(4)} USDC → treasury | tx: ${feeTx}`);
+    } catch (feeErr) {
+      // Fee transfer failure shouldn't block the job
+      console.log(`[Kompass Bridge] Fee transfer failed (non-blocking): ${feeErr instanceof Error ? feeErr.message : feeErr}`);
+    }
+  }
+
+  console.log(`[Kompass Bridge] Transferred ${netAmount.toFixed(4)} USDC to ACP wallet ${acpWalletAddress.slice(0, 10)}... | tx: ${txHash}`);
 
-  return { txHash, amount: String(amountUSDC) };
+  return { txHash, amount: String(netAmount.toFixed(4)), fee: feeUSDC.toFixed(4) };
 }
 
 // ── Lightning Swap (USDC → sats) ─────────────────────────

package/src/wallet/handlers/acp.ts

@@ -40,9 +40,10 @@ export async function handleACPPayment(
     // Job creation (REQUEST) and acceptance (NEGOTIATION) are FREE.
     // We topup only after confirming an agent accepted.
 
-    // Use ACP CLI with execFile (not execSync) to avoid shell injection
-    // Arguments passed as array, not concatenated string
-    const requirements = JSON.stringify({ description: task });
+    // Format requirements to match offering's expected schema.
+    // If the offering has a requirement template/schema, try to conform to it.
+    // Otherwise fall back to {description: task}.
+    const requirements = JSON.stringify(formatRequirements(task, offering));
 
     const { stdout } = await execFileAsync(
       "npx",
@@ -157,3 +158,68 @@ export async function handleACPPayment(
     };
   }
 }
+
+/**
+ * Format task requirements to match the offering's expected schema.
+ *
+ * ACP agents reject jobs when requirements don't match their offering's
+ * expected input format. This function:
+ * 1. Checks if the offering has a requirement schema/template
+ * 2. Tries to extract relevant fields from the natural language task
+ * 3. Falls back to {description: task} if no schema exists
+ */
+function formatRequirements(task: string, offering: any): Record<string, unknown> {
+  const schema = offering.requirement ?? offering.requirementSchema ?? offering.inputSchema;
+
+  // No schema defined — send description (most flexible)
+  if (!schema || typeof schema === "string") {
+    return { description: task };
+  }
+
+  // Schema is an object — try to populate its fields from the task
+  if (typeof schema === "object") {
+    const formatted: Record<string, unknown> = {};
+    const taskLower = task.toLowerCase();
+
+    for (const [key, spec] of Object.entries(schema)) {
+      const keyLower = key.toLowerCase();
+
+      // Try to extract Ethereum addresses for address-type fields
+      if (keyLower.includes("address") || keyLower.includes("token") || keyLower.includes("contract")) {
+        const addrMatch = task.match(/0x[a-fA-F0-9]{40}/);
+        if (addrMatch) {
+          formatted[key] = addrMatch[0];
+          continue;
+        }
+      }
+
+      // Try to extract chain/network
+      if (keyLower.includes("chain") || keyLower.includes("network")) {
+        const chains = ["base", "ethereum", "polygon", "arbitrum", "optimism", "bsc"];
+        const found = chains.find((c) => taskLower.includes(c));
+        formatted[key] = found ?? "base";
+        continue;
+      }
+
+      // Try to extract numeric amounts
+      if (keyLower.includes("amount") || keyLower.includes("quantity") || keyLower.includes("limit")) {
+        const numMatch = task.match(/\d+\.?\d*/);
+        if (numMatch) {
+          formatted[key] = parseFloat(numMatch[0]);
+          continue;
+        }
+      }
+
+      // For any other field, use the task description as the value
+      if (typeof spec === "string") {
+        formatted[key] = task; // Use full task as the value
+      }
+    }
+
+    // Always include description for context
+    formatted.description = task;
+    return formatted;
+  }
+
+  return { description: task };
+}

package/src/wallet/handlers/bankr.ts

@@ -0,0 +1,108 @@
+/**
+ * Bankr Payment Handler
+ * Routes trading tasks through Bankr's LLM Gateway
+ * POST prompt → poll for result
+ */
+
+import type { KompassWallet } from "../index.js";
+import type { UnifiedAgent } from "../../sources/types.js";
+
+const BANKR_API = "https://api.bankr.bot";
+
+export async function handleBankrPayment(
+  wallet: KompassWallet,
+  agent: UnifiedAgent,
+  task: string,
+): Promise<{ success: boolean; deliverable?: unknown; jobId?: string }> {
+  const apiKey = process.env.BANKR_API_KEY;
+  if (!apiKey) {
+    return {
+      success: false,
+      deliverable: {
+        error: "BANKR_API_KEY not configured. Set the BANKR_API_KEY environment variable.",
+        hint: "Get an API key from https://bankr.bot",
+      },
+    };
+  }
+
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "X-API-Key": apiKey,
+  };
+
+  try {
+    // Step 1: Submit prompt
+    const submitRes = await fetch(`${BANKR_API}/agent/prompt`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ prompt: task }),
+      signal: AbortSignal.timeout(30000),
+    });
+
+    if (!submitRes.ok) {
+      const errBody = await submitRes.text().catch(() => "");
+      return {
+        success: false,
+        deliverable: { error: `Bankr API error: ${submitRes.status}`, details: errBody },
+      };
+    }
+
+    const submitData = await submitRes.json();
+    const jobId = submitData.jobId ?? submitData.job_id ?? submitData.id;
+
+    // If the response is immediate (no job polling needed)
+    if (!jobId || submitData.result || submitData.response) {
+      return {
+        success: true,
+        deliverable: submitData.result ?? submitData.response ?? submitData,
+      };
+    }
+
+    // Step 2: Poll for result
+    const maxAttempts = 30;
+    const pollInterval = 2000;
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+
+      const pollRes = await fetch(`${BANKR_API}/agent/job/${jobId}`, {
+        headers,
+        signal: AbortSignal.timeout(10000),
+      });
+
+      if (!pollRes.ok) continue;
+
+      const pollData = await pollRes.json();
+      const status = pollData.status?.toLowerCase();
+
+      if (status === "completed" || status === "done" || status === "success") {
+        return {
+          success: true,
+          deliverable: pollData.result ?? pollData.response ?? pollData,
+          jobId,
+        };
+      }
+
+      if (status === "failed" || status === "error") {
+        return {
+          success: false,
+          deliverable: { error: pollData.error ?? "Job failed", details: pollData },
+          jobId,
+        };
+      }
+
+      // Still pending, continue polling
+    }
+
+    return {
+      success: false,
+      deliverable: { error: "Job timed out after polling", jobId },
+      jobId,
+    };
+  } catch (err) {
+    return {
+      success: false,
+      deliverable: { error: err instanceof Error ? err.message : String(err) },
+    };
+  }
+}