@trustthenverify/sdk 1.0.0 → 2.0.0

package/dist/index.d.ts

@@ -4,34 +4,23 @@
  * TypeScript SDK for the AI agent trust registry.
  * https://trustthenverify.com
  */
+export interface TrustDimension {
+    score: number;
+    max: number;
+}
 export interface TrustScore {
     total: number;
     confidence: number;
-    tier: number;
-    tier_label: string;
-    badge: string;
     dimensions: {
-        identity: {
-            score: number;
-            max: number;
-        };
-        economic: {
-            score: number;
-            max: number;
-        };
-        track_record: {
-            score: number;
-            max: number;
-        };
-        social: {
-            score: number;
-            max: number;
-        };
-        behavioral: {
-            score: number;
-            max: number;
-        };
+        identity: TrustDimension;
+        economic: TrustDimension;
+        social: TrustDimension;
+        behavioral: TrustDimension;
     };
+    risk_flags: string[];
+    safe_to_transact: boolean;
+    risk_level: "low" | "medium" | "high" | "unknown";
+    evidence_summary: string;
 }
 export interface Agent {
     id: string;
@@ -39,6 +28,7 @@ export interface Agent {
     description?: string;
     contact?: string;
     trust_score?: number;
+    trust_tier?: number;
     capabilities?: string[];
     lightning_pubkey?: string;
     nostr_npub?: string;
@@ -46,6 +36,17 @@ export interface Agent {
     website?: string;
     created_at?: string;
 }
+export interface PaginatedAgents {
+    agents: Agent[];
+    page: number;
+    limit: number;
+    total: number;
+    total_pages: number;
+}
+export interface ListAgentsOptions {
+    page?: number;
+    limit?: number;
+}
 export interface RegisterResponse {
     agent_id: string;
     trust_score: number;
@@ -60,9 +61,13 @@ export interface ReviewResponse {
     review_id?: string;
     error?: string;
 }
+export declare class TrustRegistryOfflineError extends Error {
+    constructor(message?: string);
+}
 export declare class TrustClient {
     private baseUrl;
     constructor(baseUrl?: string);
+    private safeFetch;
     /**
      * Look up an agent's trust score
      */
@@ -75,9 +80,25 @@ export declare class TrustClient {
      */
     getAgent(agentId: string): Promise<Agent | null>;
     /**
-     * List all registered agents
+     * List registered agents (paginated)
      */
-    listAgents(): Promise<Agent[]>;
+    listAgents(options?: ListAgentsOptions): Promise<PaginatedAgents>;
+    /**
+     * Update an agent's fields (requires auth secret = contact value)
+     */
+    updateAgent(agentId: string, updates: Partial<Pick<Agent, "description" | "capabilities" | "lightning_pubkey" | "x_handle" | "website" | "contact">>, authSecret: string): Promise<{
+        success: boolean;
+        message?: string;
+        error?: string;
+    }>;
+    /**
+     * Soft-delete an agent (requires auth secret = contact value)
+     */
+    deleteAgent(agentId: string, authSecret: string): Promise<{
+        success: boolean;
+        message?: string;
+        error?: string;
+    }>;
     /**
      * Register a new agent
      */
@@ -121,7 +142,17 @@ export declare const lookup: (agentId: string) => Promise<{
 } | null>;
 export declare const register: (name: string, contact: string, options?: Parameters<TrustClient["register"]>[2]) => Promise<RegisterResponse>;
 export declare const review: (agentId: string, rating: number, comment: string, options?: Parameters<TrustClient["review"]>[3]) => Promise<ReviewResponse>;
-export declare const listAgents: () => Promise<Agent[]>;
+export declare const listAgents: (options?: ListAgentsOptions) => Promise<PaginatedAgents>;
+export declare const updateAgent: (agentId: string, updates: Parameters<TrustClient["updateAgent"]>[1], authSecret: string) => Promise<{
+    success: boolean;
+    message?: string;
+    error?: string;
+}>;
+export declare const deleteAgent: (agentId: string, authSecret: string) => Promise<{
+    success: boolean;
+    message?: string;
+    error?: string;
+}>;
 export declare const isTrusted: (agentId: string) => Promise<boolean>;
 export declare const badgeUrl: (agentId: string) => string;
 /**

package/dist/index.js

@@ -6,18 +6,38 @@
  * https://trustthenverify.com
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.badgeUrl = exports.isTrusted = exports.listAgents = exports.review = exports.register = exports.lookup = exports.trust = exports.TrustClient = void 0;
+exports.badgeUrl = exports.isTrusted = exports.deleteAgent = exports.updateAgent = exports.listAgents = exports.review = exports.register = exports.lookup = exports.trust = exports.TrustClient = exports.TrustRegistryOfflineError = void 0;
 exports.ensureRegistered = ensureRegistered;
 exports.checkBeforeTransaction = checkBeforeTransaction;
+class TrustRegistryOfflineError extends Error {
+    constructor(message = "Trust registry is temporarily offline") {
+        super(message);
+        this.name = "TrustRegistryOfflineError";
+    }
+}
+exports.TrustRegistryOfflineError = TrustRegistryOfflineError;
 class TrustClient {
     constructor(baseUrl = "https://trustthenverify.com") {
         this.baseUrl = baseUrl.replace(/\/$/, "");
     }
+    async safeFetch(url, init) {
+        let res;
+        try {
+            res = await fetch(url, init);
+        }
+        catch (err) {
+            throw new TrustRegistryOfflineError(`Registry unreachable: ${err.message || "network error"}`);
+        }
+        if (res.status === 502 || res.status === 503 || res.status === 504) {
+            throw new TrustRegistryOfflineError(`Registry returned ${res.status}`);
+        }
+        return res;
+    }
     /**
      * Look up an agent's trust score
      */
     async lookup(agentId) {
-        const res = await fetch(`${this.baseUrl}/registry/trust/${agentId}`);
+        const res = await this.safeFetch(`${this.baseUrl}/v1/trust/${agentId}`);
         if (!res.ok)
             return null;
         return res.json();
@@ -26,37 +46,77 @@ class TrustClient {
      * Get an agent by ID
      */
     async getAgent(agentId) {
-        const res = await fetch(`${this.baseUrl}/registry/agent/${agentId}`);
+        const res = await this.safeFetch(`${this.baseUrl}/registry/agent/${agentId}`);
         if (!res.ok)
             return null;
         return res.json();
     }
     /**
-     * List all registered agents
+     * List registered agents (paginated)
      */
-    async listAgents() {
-        const res = await fetch(`${this.baseUrl}/registry/agents`);
+    async listAgents(options) {
+        const params = new URLSearchParams();
+        if (options?.page)
+            params.set("page", String(options.page));
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        const qs = params.toString();
+        const res = await this.safeFetch(`${this.baseUrl}/registry/agents${qs ? `?${qs}` : ""}`);
         if (!res.ok)
-            return [];
+            return { agents: [], page: 1, limit: 50, total: 0, total_pages: 0 };
         const data = await res.json();
-        return data.agents || [];
+        return {
+            agents: data.agents || [],
+            page: data.page || 1,
+            limit: data.limit || 50,
+            total: data.total || 0,
+            total_pages: data.total_pages || 0,
+        };
+    }
+    /**
+     * Update an agent's fields (requires auth secret = contact value)
+     */
+    async updateAgent(agentId, updates, authSecret) {
+        const res = await this.safeFetch(`${this.baseUrl}/registry/agent/${agentId}`, {
+            method: "PATCH",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Agent-Secret": authSecret,
+            },
+            body: JSON.stringify(updates),
+        });
+        return res.json();
+    }
+    /**
+     * Soft-delete an agent (requires auth secret = contact value)
+     */
+    async deleteAgent(agentId, authSecret) {
+        const res = await this.safeFetch(`${this.baseUrl}/registry/agent/${agentId}`, {
+            method: "DELETE",
+            headers: { "X-Agent-Secret": authSecret },
+        });
+        return res.json();
     }
     /**
      * Register a new agent
      */
     async register(name, contact, options) {
-        const res = await fetch(`${this.baseUrl}/register`, {
+        const res = await this.safeFetch(`${this.baseUrl}/register`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({ name, contact, ...options }),
         });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            throw new Error(body.error || `Registration failed (${res.status})`);
+        }
         return res.json();
     }
     /**
      * Submit a review for an agent
      */
     async review(agentId, rating, comment, options) {
-        const res = await fetch(`${this.baseUrl}/registry/review`, {
+        const res = await this.safeFetch(`${this.baseUrl}/registry/review`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({
@@ -66,6 +126,10 @@ class TrustClient {
                 ...options,
             }),
         });
+        if (!res.ok) {
+            const body = await res.json().catch(() => ({}));
+            throw new Error(body.error || `Review failed (${res.status})`);
+        }
         return res.json();
     }
     /**
@@ -108,8 +172,12 @@ const register = (name, contact, options) => exports.trust.register(name, contac
 exports.register = register;
 const review = (agentId, rating, comment, options) => exports.trust.review(agentId, rating, comment, options);
 exports.review = review;
-const listAgents = () => exports.trust.listAgents();
+const listAgents = (options) => exports.trust.listAgents(options);
 exports.listAgents = listAgents;
+const updateAgent = (agentId, updates, authSecret) => exports.trust.updateAgent(agentId, updates, authSecret);
+exports.updateAgent = updateAgent;
+const deleteAgent = (agentId, authSecret) => exports.trust.deleteAgent(agentId, authSecret);
+exports.deleteAgent = deleteAgent;
 const isTrusted = (agentId) => exports.trust.isTrusted(agentId);
 exports.isTrusted = isTrusted;
 const badgeUrl = (agentId) => exports.trust.badgeUrl(agentId);
@@ -128,19 +196,19 @@ exports.badgeUrl = badgeUrl;
  * });
  */
 async function ensureRegistered(options) {
-    // Check if already registered by name
-    const agents = await exports.trust.listAgents();
-    const existing = agents.find(a => a.name.toLowerCase() === options.name.toLowerCase());
+    // Search by name instead of listing all agents
+    const result = await exports.trust.listAgents({ limit: 50 });
+    const existing = result.agents.find(a => a.name.toLowerCase() === options.name.toLowerCase());
     if (existing) {
         return existing.id;
     }
     // Register new agent
-    const result = await exports.trust.register(options.name, options.contact || `sdk-auto-${Date.now()}`, {
+    const regResult = await exports.trust.register(options.name, options.contact || `sdk-auto-${Date.now()}`, {
         description: options.description,
         nostr_npub: options.npub,
         lightning_pubkey: options.lightning_pubkey,
     });
-    return result.agent_id;
+    return regResult.agent_id;
 }
 /**
  * Check trust before transaction helper

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trustthenverify/sdk",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "TypeScript SDK for the Trust Then Verify agent registry",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -1,23 +1,28 @@
 /**
  * Trust Then Verify SDK
- * 
+ *
  * TypeScript SDK for the AI agent trust registry.
  * https://trustthenverify.com
  */
 
+export interface TrustDimension {
+  score: number;
+  max: number;
+}
+
 export interface TrustScore {
   total: number;
   confidence: number;
-  tier: number;
-  tier_label: string;
-  badge: string;
   dimensions: {
-    identity: { score: number; max: number };
-    economic: { score: number; max: number };
-    track_record: { score: number; max: number };
-    social: { score: number; max: number };
-    behavioral: { score: number; max: number };
+    identity: TrustDimension;
+    economic: TrustDimension;
+    social: TrustDimension;
+    behavioral: TrustDimension;
   };
+  risk_flags: string[];
+  safe_to_transact: boolean;
+  risk_level: "low" | "medium" | "high" | "unknown";
+  evidence_summary: string;
 }
 
 export interface Agent {
@@ -26,6 +31,7 @@ export interface Agent {
   description?: string;
   contact?: string;
   trust_score?: number;
+  trust_tier?: number;
   capabilities?: string[];
   lightning_pubkey?: string;
   nostr_npub?: string;
@@ -34,6 +40,19 @@ export interface Agent {
   created_at?: string;
 }
 
+export interface PaginatedAgents {
+  agents: Agent[];
+  page: number;
+  limit: number;
+  total: number;
+  total_pages: number;
+}
+
+export interface ListAgentsOptions {
+  page?: number;
+  limit?: number;
+}
+
 export interface RegisterResponse {
   agent_id: string;
   trust_score: number;
@@ -47,6 +66,13 @@ export interface ReviewResponse {
   error?: string;
 }
 
+export class TrustRegistryOfflineError extends Error {
+  constructor(message = "Trust registry is temporarily offline") {
+    super(message);
+    this.name = "TrustRegistryOfflineError";
+  }
+}
+
 export class TrustClient {
   private baseUrl: string;
 
@@ -54,11 +80,28 @@ export class TrustClient {
     this.baseUrl = baseUrl.replace(/\/$/, "");
   }
 
+  private async safeFetch(url: string, init?: RequestInit): Promise<Response> {
+    let res: Response;
+    try {
+      res = await fetch(url, init);
+    } catch (err: any) {
+      throw new TrustRegistryOfflineError(
+        `Registry unreachable: ${err.message || "network error"}`
+      );
+    }
+    if (res.status === 502 || res.status === 503 || res.status === 504) {
+      throw new TrustRegistryOfflineError(
+        `Registry returned ${res.status}`
+      );
+    }
+    return res;
+  }
+
   /**
    * Look up an agent's trust score
    */
   async lookup(agentId: string): Promise<{ agent: Agent; trust_score: TrustScore } | null> {
-    const res = await fetch(`${this.baseUrl}/registry/trust/${agentId}`);
+    const res = await this.safeFetch(`${this.baseUrl}/v1/trust/${agentId}`);
     if (!res.ok) return null;
     return res.json();
   }
@@ -67,19 +110,62 @@ export class TrustClient {
    * Get an agent by ID
    */
   async getAgent(agentId: string): Promise<Agent | null> {
-    const res = await fetch(`${this.baseUrl}/registry/agent/${agentId}`);
+    const res = await this.safeFetch(`${this.baseUrl}/registry/agent/${agentId}`);
     if (!res.ok) return null;
     return res.json();
   }
 
   /**
-   * List all registered agents
+   * List registered agents (paginated)
    */
-  async listAgents(): Promise<Agent[]> {
-    const res = await fetch(`${this.baseUrl}/registry/agents`);
-    if (!res.ok) return [];
+  async listAgents(options?: ListAgentsOptions): Promise<PaginatedAgents> {
+    const params = new URLSearchParams();
+    if (options?.page) params.set("page", String(options.page));
+    if (options?.limit) params.set("limit", String(options.limit));
+    const qs = params.toString();
+    const res = await this.safeFetch(`${this.baseUrl}/registry/agents${qs ? `?${qs}` : ""}`);
+    if (!res.ok) return { agents: [], page: 1, limit: 50, total: 0, total_pages: 0 };
     const data = await res.json();
-    return data.agents || [];
+    return {
+      agents: data.agents || [],
+      page: data.page || 1,
+      limit: data.limit || 50,
+      total: data.total || 0,
+      total_pages: data.total_pages || 0,
+    };
+  }
+
+  /**
+   * Update an agent's fields (requires auth secret = contact value)
+   */
+  async updateAgent(
+    agentId: string,
+    updates: Partial<Pick<Agent, "description" | "capabilities" | "lightning_pubkey" | "x_handle" | "website" | "contact">>,
+    authSecret: string
+  ): Promise<{ success: boolean; message?: string; error?: string }> {
+    const res = await this.safeFetch(`${this.baseUrl}/registry/agent/${agentId}`, {
+      method: "PATCH",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Agent-Secret": authSecret,
+      },
+      body: JSON.stringify(updates),
+    });
+    return res.json();
+  }
+
+  /**
+   * Soft-delete an agent (requires auth secret = contact value)
+   */
+  async deleteAgent(
+    agentId: string,
+    authSecret: string
+  ): Promise<{ success: boolean; message?: string; error?: string }> {
+    const res = await this.safeFetch(`${this.baseUrl}/registry/agent/${agentId}`, {
+      method: "DELETE",
+      headers: { "X-Agent-Secret": authSecret },
+    });
+    return res.json();
   }
 
   /**
@@ -97,11 +183,15 @@ export class TrustClient {
       website?: string;
     }
   ): Promise<RegisterResponse> {
-    const res = await fetch(`${this.baseUrl}/register`, {
+    const res = await this.safeFetch(`${this.baseUrl}/register`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({ name, contact, ...options }),
     });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw new Error(body.error || `Registration failed (${res.status})`);
+    }
     return res.json();
   }
 
@@ -118,7 +208,7 @@ export class TrustClient {
       proof_of_payment?: string;
     }
   ): Promise<ReviewResponse> {
-    const res = await fetch(`${this.baseUrl}/registry/review`, {
+    const res = await this.safeFetch(`${this.baseUrl}/registry/review`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
@@ -128,6 +218,10 @@ export class TrustClient {
         ...options,
       }),
     });
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw new Error(body.error || `Review failed (${res.status})`);
+    }
     return res.json();
   }
 
@@ -168,16 +262,19 @@ export const register = (name: string, contact: string, options?: Parameters<Tru
   trust.register(name, contact, options);
 export const review = (agentId: string, rating: number, comment: string, options?: Parameters<TrustClient["review"]>[3]) =>
   trust.review(agentId, rating, comment, options);
-export const listAgents = () => trust.listAgents();
+export const listAgents = (options?: ListAgentsOptions) => trust.listAgents(options);
+export const updateAgent = (agentId: string, updates: Parameters<TrustClient["updateAgent"]>[1], authSecret: string) =>
+  trust.updateAgent(agentId, updates, authSecret);
+export const deleteAgent = (agentId: string, authSecret: string) => trust.deleteAgent(agentId, authSecret);
 export const isTrusted = (agentId: string) => trust.isTrusted(agentId);
 export const badgeUrl = (agentId: string) => trust.badgeUrl(agentId);
 
 /**
  * Auto-register helper for agents
- * 
+ *
  * Ensures the calling agent is registered before making lookups.
  * Returns the agent ID for future reference.
- * 
+ *
  * @example
  * const myId = await ensureRegistered({
  *   name: "MyAgent",
@@ -192,16 +289,16 @@ export async function ensureRegistered(options: {
   lightning_pubkey?: string;
   description?: string;
 }): Promise<string> {
-  // Check if already registered by name
-  const agents = await trust.listAgents();
-  const existing = agents.find(a => a.name.toLowerCase() === options.name.toLowerCase());
-  
+  // Search by name instead of listing all agents
+  const result = await trust.listAgents({ limit: 50 });
+  const existing = result.agents.find(a => a.name.toLowerCase() === options.name.toLowerCase());
+
   if (existing) {
     return existing.id;
   }
-  
+
   // Register new agent
-  const result = await trust.register(
+  const regResult = await trust.register(
     options.name,
     options.contact || `sdk-auto-${Date.now()}`,
     {
@@ -210,15 +307,15 @@ export async function ensureRegistered(options: {
       lightning_pubkey: options.lightning_pubkey,
     }
   );
-  
-  return result.agent_id;
+
+  return regResult.agent_id;
 }
 
 /**
  * Check trust before transaction helper
- * 
+ *
  * Returns detailed recommendation for whether to proceed.
- * 
+ *
  * @example
  * const check = await checkBeforeTransaction("target-agent", 1000);
  * if (check.proceed) {
@@ -237,7 +334,7 @@ export async function checkBeforeTransaction(
   riskLevel: "low" | "medium" | "high" | "unknown";
 }> {
   const result = await trust.lookup(agentId);
-  
+
   if (!result) {
     return {
       proceed: false,
@@ -246,13 +343,13 @@ export async function checkBeforeTransaction(
       riskLevel: "unknown",
     };
   }
-  
+
   const score = result.trust_score.total;
   const tier = TrustClient.getTier(score);
-  
+
   // High amounts require higher trust
   const requiredScore = amountSats > 10000 ? 60 : amountSats > 1000 ? 40 : 20;
-  
+
   if (score >= requiredScore) {
     return {
       proceed: true,
@@ -261,7 +358,7 @@ export async function checkBeforeTransaction(
       riskLevel: tier.safe ? "low" : "medium",
     };
   }
-  
+
   return {
     proceed: false,
     score,