kompass-sdk 0.19.0 → 0.21.0

package/src/sources/olas.ts

@@ -1,11 +1,11 @@
 /**
  * Olas Mech Marketplace Source Adapter
  * Queries the Olas marketplace subgraph (The Graph) to discover AI agent mechs.
- * Mechs are autonomous agents that accept prompts and return deliverables.
- * Supports Gnosis, Base, Polygon, Optimism chains.
+ * Mechs are autonomous agents that accept on-chain requests and return deliverables.
+ * Interaction is on-chain via the mech-client CLI or Python SDK — no HTTP API.
  *
  * Subgraph: https://api.subgraph.autonolas.tech/api/proxy/marketplace-{chain}
- * Docs: https://docs.olas.network
+ * Docs: https://docs.olas.network/mech-client/
  */
 
 import type { SourceAdapter, UnifiedAgent, SourceSearchOptions } from "./types.js";
@@ -15,43 +15,49 @@ const SUBGRAPH_URLS: Record<string, string> = {
   base: "https://api.subgraph.autonolas.tech/api/proxy/marketplace-base",
 };
 
-const MECH_AGENTS_QUERY = `{
-  mechAgents(first: 50, orderBy: totalTransactions, orderDirection: desc) {
+// Query the correct "meches" entity with real fields from the subgraph schema
+const MECHES_QUERY = `{
+  meches(first: 50, orderBy: receivedRequests, orderDirection: desc) {
     id
     address
-    agentHash
-    totalTransactions
-    service {
-      serviceId
-      totalRequests
-      totalDeliveries
-    }
+    configHash
+    owner
+    receivedRequests
+    totalDeliveriesTransactions
+    selfDeliveredFromReceived
+    deliveredByOthersFromReceived
+    karma
+    maxDeliveryRate
+    paymentType
   }
 }`;
 
-interface MechAgent {
+interface MechData {
   id: string;
   address: string;
-  agentHash: string;
-  totalTransactions: string;
-  service?: {
-    serviceId: string;
-    totalRequests: string;
-    totalDeliveries: string;
-  };
+  configHash: string;
+  owner: string;
+  receivedRequests: string;
+  totalDeliveriesTransactions: string;
+  selfDeliveredFromReceived: string;
+  deliveredByOthersFromReceived: string;
+  karma: string;
+  maxDeliveryRate: string | null;
+  paymentType: string;
+  _chain?: string;
 }
 
 // Cache mechs — refresh every 10 minutes
-let mechCache: MechAgent[] | null = null;
+let mechCache: MechData[] | null = null;
 let cacheTime = 0;
 const CACHE_TTL = 10 * 60 * 1000;
 
-async function fetchMechs(timeout: number): Promise<MechAgent[]> {
+async function fetchMechs(timeout: number): Promise<MechData[]> {
   if (mechCache && Date.now() - cacheTime < CACHE_TTL) {
     return mechCache;
   }
 
-  const allMechs: MechAgent[] = [];
+  const allMechs: MechData[] = [];
 
   // Query both Gnosis and Base subgraphs
   for (const [chain, url] of Object.entries(SUBGRAPH_URLS)) {
@@ -59,17 +65,17 @@ async function fetchMechs(timeout: number): Promise<MechAgent[]> {
       const res = await fetch(url, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ query: MECH_AGENTS_QUERY }),
+        body: JSON.stringify({ query: MECHES_QUERY }),
         signal: AbortSignal.timeout(timeout),
       });
 
       if (!res.ok) continue;
 
       const json = await res.json();
-      const agents = json.data?.mechAgents ?? [];
+      const mechs = json.data?.meches ?? [];
 
-      for (const agent of agents) {
-        allMechs.push({ ...agent, _chain: chain } as any);
+      for (const mech of mechs) {
+        allMechs.push({ ...mech, _chain: chain });
       }
     } catch {
       // Chain subgraph unavailable, continue with others
@@ -98,7 +104,6 @@ export const olasAdapter: SourceAdapter = {
       if (!query) return mechs.slice(0, limit).map(mapMech);
 
       // Score mechs by transaction volume and filter by relevance
-      // Since mechs don't have descriptions, match against known tool categories
       const lower = query.toLowerCase();
       const relevant = mechs.filter(() => {
         // Olas mechs handle: predictions, research, analysis, trading signals
@@ -107,7 +112,7 @@ export const olasAdapter: SourceAdapter = {
       });
 
       return relevant
-        .sort((a, b) => parseInt(b.totalTransactions) - parseInt(a.totalTransactions))
+        .sort((a, b) => parseInt(b.receivedRequests) - parseInt(a.receivedRequests))
         .slice(0, limit)
         .map(mapMech);
     } catch {
@@ -120,7 +125,7 @@ export const olasAdapter: SourceAdapter = {
       const res = await fetch(SUBGRAPH_URLS.gnosis, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ query: "{ global(id: \"global\") { totalMechs } }" }),
+        body: JSON.stringify({ query: "{ globals(first: 1) { id } }" }),
         signal: AbortSignal.timeout(5000),
       });
       return res.ok;
@@ -130,18 +135,20 @@ export const olasAdapter: SourceAdapter = {
   },
 };
 
-function mapMech(mech: MechAgent): UnifiedAgent {
-  const chain = (mech as any)._chain || "gnosis";
-  const txCount = parseInt(mech.totalTransactions) || 0;
-  const deliveries = parseInt(mech.service?.totalDeliveries || "0");
-  const requests = parseInt(mech.service?.totalRequests || "0");
-  const successRate = requests > 0 ? Math.round((deliveries / requests) * 100) : 0;
+function mapMech(mech: MechData): UnifiedAgent {
+  const chain = mech._chain || "gnosis";
+  const requests = parseInt(mech.receivedRequests) || 0;
+  const totalDeliveries = parseInt(mech.totalDeliveriesTransactions) || 0;
+  const selfDelivered = parseInt(mech.selfDeliveredFromReceived) || 0;
+  const othersDelivered = parseInt(mech.deliveredByOthersFromReceived) || 0;
+  const karma = parseInt(mech.karma) || 0;
+  const successRate = requests > 0 ? Math.round(((selfDelivered + othersDelivered) / requests) * 100) : 0;
 
   return {
     id: `olas:${chain}:${mech.address}`,
     nativeId: mech.address,
     name: `Olas Mech ${mech.address.slice(0, 8)}...${mech.address.slice(-4)}`,
-    description: `Autonomous AI agent on Olas Marketplace (${chain}). ${txCount} transactions, ${deliveries} deliveries. Accepts prompts and returns AI-powered results via on-chain requests.`,
+    description: `Autonomous AI mech on Olas Marketplace (${chain}). ${requests} requests, ${totalDeliveries} deliveries, karma: ${karma}. Accepts on-chain requests via mech-client.`,
     categories: ["ai", "autonomous", "prediction"],
     capabilities: [
       "AI prompt execution",
@@ -150,22 +157,24 @@ function mapMech(mech: MechAgent): UnifiedAgent {
       "On-chain autonomous operation",
     ],
     source: "olas" as any,
-    protocol: "http",
+    // Olas mechs are on-chain only — no HTTP API
+    protocol: "onchain",
     endpoints: {
-      http: `https://mech.tech/mech/${mech.address}`,
+      // No HTTP endpoint — interaction is on-chain via mech-client
+      http: undefined,
     },
     reputation: {
       score: successRate,
-      count: deliveries,
+      count: totalDeliveries,
       source: `olas-${chain}`,
     },
     pricing: {
       model: "per-call",
-      amount: "0.01",
-      currency: "OLAS",
+      amount: mech.maxDeliveryRate ? (parseInt(mech.maxDeliveryRate) / 1e18).toFixed(6) : "0.01",
+      currency: "xDAI",
     },
-    verified: txCount > 10,
-    lastSeen: txCount > 0 ? Date.now() : undefined,
+    verified: requests > 10,
+    lastSeen: requests > 0 ? Date.now() : undefined,
     raw: mech,
   };
 }

package/src/wallet/handlers/bankr.ts

@@ -75,22 +75,24 @@ export async function handleBankrPayment(
       const pollData = await pollRes.json();
       const status = pollData.status?.toLowerCase();
 
-      if (status === "completed" || status === "done" || status === "success") {
+      if (status === "completed") {
         return {
           success: true,
-          deliverable: pollData.result ?? pollData.response ?? pollData,
+          deliverable: pollData.response ?? pollData.result ?? pollData,
           jobId,
         };
       }
 
-      if (status === "failed" || status === "error") {
+      if (status === "failed" || status === "cancelled") {
         return {
           success: false,
-          deliverable: { error: pollData.error ?? "Job failed", details: pollData },
+          deliverable: { error: pollData.error ?? `Job ${status}`, details: pollData },
           jobId,
         };
       }
 
+      // "pending" or "processing" — continue polling
+
       // Still pending, continue polling
     }
 

package/src/wallet/handlers/locus.ts

@@ -124,9 +124,10 @@ export async function handleLocusPayment(
       }
 
       const result = await callRes.json();
+      // Locus wraps responses in { success: true, data: {...} }
       return {
-        success: true,
-        deliverable: result,
+        success: result.success ?? true,
+        deliverable: result.data ?? result,
       };
     }
 

package/src/wallet/handlers/olas.ts

@@ -1,6 +1,10 @@
 /**
  * Olas Mech Handler
- * Sends requests to Olas autonomous mechs via their HTTP endpoint
+ * Olas mechs are on-chain agents — requests and deliveries happen via smart contracts.
+ * There is no HTTP API. Interaction requires the mech-client CLI/Python SDK
+ * or direct on-chain transactions.
+ *
+ * Docs: https://docs.olas.network/mech-client/
  */
 import type { KompassWallet } from "../index.js";
 import type { UnifiedAgent } from "../../sources/types.js";
@@ -10,34 +14,25 @@ export async function handleOlasPayment(
   agent: UnifiedAgent,
   task: string,
 ): Promise<{ success: boolean; deliverable?: unknown; jobId?: string }> {
-  const endpoint = agent.endpoints.http;
-  if (!endpoint) {
-    return { success: false, deliverable: { error: "No Olas mech endpoint" } };
-  }
+  // Olas mechs require on-chain interaction via the Mech Marketplace contract.
+  // Direct HTTP calls are not supported — the mech-client discovers the off-chain URL
+  // from on-chain metadata and handles the full request/delivery lifecycle.
+  const mechAddress = agent.nativeId;
+  const chain = (agent.raw as any)?._chain ?? "gnosis";
 
-  try {
-    // Olas mechs accept POST requests with prompt
-    const res = await fetch(endpoint, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        prompt: task,
-        tool: "openai-gpt-4", // Default tool
-      }),
-      signal: AbortSignal.timeout(30000),
-    });
-
-    if (!res.ok) {
-      const err = await res.text().catch(() => "");
-      return { success: false, deliverable: { error: `Olas mech error: ${res.status}`, details: err } };
-    }
-
-    const data = await res.json();
-    return { success: true, deliverable: data };
-  } catch (err) {
-    return {
-      success: false,
-      deliverable: { error: err instanceof Error ? err.message : String(err) },
-    };
-  }
+  return {
+    success: false,
+    deliverable: {
+      error: "Olas mechs require on-chain interaction",
+      mechAddress,
+      chain,
+      hint: "Install mech-client: pip install mech-client. Then use: mechx request --prompts '<prompt>' --tools openai-gpt-4 --chain-config <chain>",
+      docsUrl: "https://docs.olas.network/mech-client/",
+      subgraphData: {
+        requests: (agent.raw as any)?.receivedRequests,
+        deliveries: (agent.raw as any)?.totalDeliveriesTransactions,
+        karma: (agent.raw as any)?.karma,
+      },
+    },
+  };
 }