@agenttool/sdk 0.2.2 → 0.2.4

package/README.md

@@ -1,10 +1,11 @@
 # @agenttool/sdk · TypeScript
 
-> Persistent memory, verified actions, and tool access for AI agents — one API key.
+> Persistent memory, reasoning traces, fact verification, tool access, and agent-to-agent payments — one API key.
 
 [![npm](https://img.shields.io/npm/v/@agenttool/sdk)](https://www.npmjs.com/package/@agenttool/sdk)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.x-blue)](https://www.typescriptlang.org/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+[![API Status](https://img.shields.io/badge/API-live-brightgreen)](https://api.agenttool.dev/health)
 
 ```bash
 npm install @agenttool/sdk
@@ -19,11 +20,12 @@ AgentTool gives AI agents the infrastructure they need to operate reliably:
 | Service | What it does |
 |---------|-------------|
 | **agent-memory** | Persistent semantic memory — store facts, retrieve by similarity |
-| **agent-tools** | Web search, page scraping, code execution |
-| **agent-verify** | SHA-256 proof-of-work attestations with timestamps |
-| **agent-economy** | Wallets, credits, agent-to-agent billing |
+| **agent-tools** | Web search, page scraping, sandboxed code execution |
+| **agent-verify** | Fact-check claims with AI-powered evidence gathering |
+| **agent-economy** | Wallets, spending policies, escrow, agent-to-agent payments |
+| **agent-trace** | Reasoning provenance — log and search decision traces |
 
-All four services, one API key, one SDK.
+All five services, one API key, one SDK.
 
 ## Quick start (60 seconds)
 
@@ -53,8 +55,8 @@ const results = await at.memory.search({
   limit: 5,
 });
 
-for (const result of results) {
-  console.log(`${result.score.toFixed(2)}  ${result.content}`);
+for (const r of results) {
+  console.log(`${r.score.toFixed(2)}  ${r.content}`);
 }
 ```
 
@@ -63,78 +65,117 @@ for (const result of results) {
 ### Memory
 
 ```typescript
-import { AgentTool } from "@agenttool/sdk";
-
 const at = new AgentTool({ apiKey: "at_..." }); // or use AT_API_KEY env var
 
 // Store
-const mem = await at.memory.store({
-  content: "User is based in London, timezone Europe/London",
-});
+const mem = await at.memory.store({ content: "User is in London, timezone Europe/London" });
 
-// Search (semantic)
-const results = await at.memory.search({ query: "where is the user?" });
+// Semantic search
+const results = await at.memory.search({ query: "where is the user?", limit: 5 });
 
 // Retrieve by ID
-const mem2 = await at.memory.get("mem_...");
+const mem = await at.memory.get("mem_abc123");
 
-// Delete
-await at.memory.delete("mem_...");
+// Usage stats
+const stats = await at.memory.usage();
+console.log(stats.memoriesStored, stats.searchesPerformed);
 ```
 
 ### Tools
 
 ```typescript
 // Web search
-const results = await at.tools.search({ query: "latest papers on RAG", numResults: 5 });
-for (const r of results) {
-  console.log(r.title, r.url);
-}
+const results = await at.tools.search("latest papers on RAG", { numResults: 5 });
+for (const r of results) console.log(r.title, r.url);
 
 // Scrape a page
-const page = await at.tools.scrape({ url: "https://example.com" });
-console.log(page.text);
-
-// Execute code
-const output = await at.tools.execute({ code: "console.log(Math.PI)" });
-console.log(output.stdout);
+const page = await at.tools.scrape("https://example.com");
+console.log(page.content);      // page text/HTML
+console.log(page.statusCode);
+
+// Execute code (sandboxed — Python, JavaScript, Bash)
+const result = await at.tools.execute("print(42)", { language: "python" });
+console.log(result.output);     // stdout
+console.log(result.error);      // stderr
+console.log(result.exitCode);   // 0 = success
 ```
 
 ### Verify
 
 ```typescript
-// Create an attestation
-const proof = await at.verify.create({
-  action: "task_completed",
-  agentId: "my-agent",
-  payload: { task: "data_analysis", rowsProcessed: 1500 },
+// Fact-check a claim with AI-powered evidence gathering
+const result = await at.verify.check("The Eiffel Tower is 330 metres tall.");
+console.log(result.verdict);      // "verified" | "false" | "disputed" | "unverifiable"
+console.log(result.confidence);   // 0.0 – 1.0
+console.log(result.caveats);      // string[] of nuances
+
+// With domain hint for better evidence
+const r = await at.verify.check("Bitcoin was created in 2009.", {
+  domain: "finance",             // "finance" | "science" | "medical" | "legal" | "general"
+  context: "On the whitepaper publication date",
 });
-console.log(proof.attestationId, proof.hash);
-
-// Verify an attestation
-const result = await at.verify.check("att_...");
-console.log(result.valid); // true
 ```
 
-### Economy
+### Economy (wallets & escrows)
 
 ```typescript
 // Create a wallet
-const wallet = await at.economy.createWallet({ name: "agent-wallet" });
+const wallet = await at.economy.createWallet({ name: "agent-wallet", agentId: "agent-42" });
 
-// Check balance
-const { balance } = await at.economy.getBalance(wallet.id);
+// Fund it
+await at.economy.fundWallet(wallet.id, { amount: 500, description: "Weekly budget" });
 
-// Transfer credits
-await at.economy.transfer({
-  fromWallet: wallet.id,
-  toWallet: "wlt_...",
+// Spend credits
+await at.economy.spend(wallet.id, {
   amount: 10,
-  memo: "payment for search service",
+  counterparty: "wal_target_id",
+  description: "Payment for research task",
+});
+
+// Set a spending policy
+await at.economy.setPolicy(wallet.id, {
+  maxPerTransaction: 50,
+  maxPerHour: 200,
+  maxPerDay: 1000,
+});
+
+// Escrow: lock credits until work is done
+const escrow = await at.economy.createEscrow({
+  creatorWalletId: wallet.id,
+  amount: 100,
+  description: "Summarise 50 research papers",
+  deadline: "2026-03-14T12:00:00Z",
+});
+// Worker accepts:
+await at.economy.acceptEscrow(escrow.id, "wal_worker");
+// Release on completion:
+await at.economy.releaseEscrow(escrow.id);
+```
+
+### Traces (reasoning provenance)
+
+```typescript
+// Store a reasoning trace
+const trace = await at.traces.store({
+  step: "web_search",
+  input: { query: "climate change solutions" },
+  output: { results: ["..."] },
+});
+
+// Semantic search across traces
+const results = await at.traces.search({
+  query: "decisions about climate data",
+  limit: 5,
 });
+
+// Get a chain of reasoning steps
+const chain = await at.traces.chain("parent_trace_id");
+
+// Delete
+await at.traces.delete(trace.id);
 ```
 
-## Integration example — Vercel AI SDK
+## Integration example — LangChain / Vercel AI SDK
 
 ```typescript
 import { AgentTool } from "@agenttool/sdk";
@@ -143,48 +184,34 @@ import { z } from "zod";
 
 const at = new AgentTool();
 
-export const memoryTools = {
+const tools = {
   remember: tool({
     description: "Store a memory for later retrieval",
     parameters: z.object({ content: z.string() }),
     execute: async ({ content }) => {
-      const mem = await at.memory.store({ content, agentId: "vercel-ai-agent" });
-      return { id: mem.id, stored: true };
+      const mem = await at.memory.store({ content, agentId: "my-agent" });
+      return `Stored memory ${mem.id}`;
     },
   }),
   recall: tool({
     description: "Search past memories by semantic similarity",
     parameters: z.object({ query: z.string() }),
     execute: async ({ query }) => {
-      const results = await at.memory.search({ query, limit: 5 });
-      return results.map((r) => ({ content: r.content, score: r.score }));
+      const results = await at.memory.search({ query, limit: 3 });
+      return results.map((r) => r.content).join("\n");
+    },
+  }),
+  factCheck: tool({
+    description: "Verify whether a factual claim is true",
+    parameters: z.object({ claim: z.string() }),
+    execute: async ({ claim }) => {
+      const result = await at.verify.check(claim);
+      return `${result.verdict} (${(result.confidence * 100).toFixed(0)}% confidence)`;
     },
   }),
 };
 ```
 
-## Integration example — any agent loop
-
-```typescript
-import { AgentTool } from "@agenttool/sdk";
-
-const at = new AgentTool();
-
-async function agentLoop(userMessage: string): Promise<string> {
-  // Recall relevant memories
-  const memories = await at.memory.search({ query: userMessage, limit: 5 });
-  const context = memories.map((m) => m.content).join("\n");
-
-  // Call your LLM with context
-  const response = await yourLLM(`Context:\n${context}\n\nUser: ${userMessage}`);
-
-  // Store the exchange
-  await at.memory.store({ content: `User: ${userMessage}\nAgent: ${response}` });
-
-  return response;
-}
-```
-
 ## Free tier
 
 | Resource | Free | Seed ($29/mo) | Grow ($99/mo) |
@@ -192,6 +219,7 @@ async function agentLoop(userMessage: string): Promise<string> {
 | Memory ops/day | 100 | 10,000 | 100,000 |
 | Tool calls/day | 10 | 500 | 5,000 |
 | Verifications/day | 5 | 100 | 1,000 |
+| Traces/day | 100 | 10,000 | 100,000 |
 
 [Upgrade at app.agenttool.dev/billing](https://app.agenttool.dev/billing)
 
@@ -201,9 +229,9 @@ async function agentLoop(userMessage: string): Promise<string> {
 import { AgentTool } from "@agenttool/sdk";
 
 const at = new AgentTool({
-  apiKey: "at_...",                          // default: AT_API_KEY env var
-  baseUrl: "https://api.agenttool.dev",      // default
-  timeout: 30_000,                           // ms, default 30s
+  apiKey: "at_...",           // default: AT_API_KEY env var
+  baseUrl: "https://api.agenttool.dev",  // default
+  timeout: 30_000,            // ms
 });
 ```
 
@@ -213,7 +241,7 @@ const at = new AgentTool({
 - 📖 [docs.agenttool.dev](https://docs.agenttool.dev)
 - 🎛️ [app.agenttool.dev](https://app.agenttool.dev) — dashboard + API key
 - 📦 [npm](https://www.npmjs.com/package/@agenttool/sdk)
-- 🐍 [Python SDK](https://github.com/cambridgetcg/agenttool-sdk-py)
+- 🐍 [Python SDK](https://github.com/mynameisyou-cmyk/agenttool-sdk-py)
 
 ## License
 

package/dist/economy.d.ts

@@ -1,27 +1,108 @@
 /**
- * Economy client for the wallet/economy API.
+ * Economy client for the wallet/escrow API.
  */
-import type { CreateWalletOptions, Wallet } from "./types.js";
+import type { CreateEscrowOptions, CreateWalletOptions, Escrow, Wallet, WalletPolicy } from "./types.js";
 import type { HttpConfig } from "./memory.js";
 /**
- * Client for the economy/wallet API.
+ * Client for the agent-economy API — wallets and escrows.
  *
  * @example
  * ```ts
  * const at = new AgentTool();
- * const wallet = await at.economy.createWallet({ name: "my-wallet" });
- * console.log(wallet.id, wallet.balance);
+ *
+ * // Create and fund a wallet
+ * const wallet = await at.economy.createWallet({ name: "agent-wallet", agentId: "agent-1" });
+ * await at.economy.fundWallet(wallet.id, { amount: 500, description: "Weekly budget" });
+ *
+ * // Create an escrow for agent-to-agent payment
+ * const escrow = await at.economy.createEscrow({
+ *   creatorWalletId: wallet.id,
+ *   amount: 100,
+ *   description: "Summarise 50 research papers",
+ * });
+ * await at.economy.releaseEscrow(escrow.id);
  * ```
  */
 export declare class EconomyClient {
     private readonly http;
     /** @internal */
     constructor(http: HttpConfig);
+    private url;
+    private req;
     /**
      * Create a new wallet.
-     *
-     * @param options - Wallet creation options (name required).
-     * @returns The created Wallet object.
      */
     createWallet(options: CreateWalletOptions): Promise<Wallet>;
+    /**
+     * List all wallets for this project.
+     */
+    listWallets(): Promise<Wallet[]>;
+    /**
+     * Get a wallet by ID.
+     */
+    getWallet(walletId: string): Promise<Wallet>;
+    /**
+     * Fund a wallet with credits.
+     */
+    fundWallet(walletId: string, options: {
+        amount: number;
+        description?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * Spend credits from a wallet (subject to spending policy).
+     */
+    spend(walletId: string, options: {
+        amount: number;
+        counterparty: string;
+        description: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<Record<string, unknown>>;
+    /**
+     * Set or update a wallet's spending policy.
+     */
+    setPolicy(walletId: string, policy: WalletPolicy): Promise<Record<string, unknown>>;
+    /**
+     * Freeze a wallet — halts all spending immediately.
+     */
+    freezeWallet(walletId: string): Promise<Wallet>;
+    /**
+     * Unfreeze a wallet to resume normal operation.
+     */
+    unfreezeWallet(walletId: string): Promise<Wallet>;
+    /**
+     * Get paginated transaction history for a wallet.
+     */
+    getTransactions(walletId: string, options?: {
+        limit?: number;
+        offset?: number;
+    }): Promise<Record<string, unknown>[]>;
+    /**
+     * Create an escrow — locks credits until work is released or refunded.
+     */
+    createEscrow(options: CreateEscrowOptions): Promise<Escrow>;
+    /**
+     * List escrows, optionally filtered by status.
+     */
+    listEscrows(status?: Escrow["status"]): Promise<Escrow[]>;
+    /**
+     * Get an escrow by ID.
+     */
+    getEscrow(escrowId: string): Promise<Escrow>;
+    /**
+     * Accept an escrow as the worker.
+     */
+    acceptEscrow(escrowId: string, workerWalletId: string): Promise<Escrow>;
+    /**
+     * Release escrow funds to the worker.
+     */
+    releaseEscrow(escrowId: string): Promise<Escrow>;
+    /**
+     * Refund escrow credits back to the creator.
+     */
+    refundEscrow(escrowId: string): Promise<Escrow>;
+    /**
+     * Flag an escrow as disputed — credits stay locked pending resolution.
+     */
+    disputeEscrow(escrowId: string): Promise<Escrow>;
 }

package/dist/economy.js

@@ -1,15 +1,25 @@
 /**
- * Economy client for the wallet/economy API.
+ * Economy client for the wallet/escrow API.
  */
 import { AgentToolError } from "./errors.js";
 /**
- * Client for the economy/wallet API.
+ * Client for the agent-economy API — wallets and escrows.
  *
  * @example
  * ```ts
  * const at = new AgentTool();
- * const wallet = await at.economy.createWallet({ name: "my-wallet" });
- * console.log(wallet.id, wallet.balance);
+ *
+ * // Create and fund a wallet
+ * const wallet = await at.economy.createWallet({ name: "agent-wallet", agentId: "agent-1" });
+ * await at.economy.fundWallet(wallet.id, { amount: 500, description: "Weekly budget" });
+ *
+ * // Create an escrow for agent-to-agent payment
+ * const escrow = await at.economy.createEscrow({
+ *   creatorWalletId: wallet.id,
+ *   amount: 100,
+ *   description: "Summarise 50 research papers",
+ * });
+ * await at.economy.releaseEscrow(escrow.id);
  * ```
  */
 export class EconomyClient {
@@ -18,34 +28,179 @@ export class EconomyClient {
     constructor(http) {
         this.http = http;
     }
-    /**
-     * Create a new wallet.
-     *
-     * @param options - Wallet creation options (name required).
-     * @returns The created Wallet object.
-     */
-    async createWallet(options) {
-        const body = { name: options.name };
-        const url = `${this.http.baseUrl}/v1/wallets`;
+    // ── helpers ──────────────────────────────────────────────────────────────
+    url(path) {
+        return `${this.http.baseUrl}${path}`;
+    }
+    async req(method, path, body, params) {
+        let url = this.url(path);
+        if (params) {
+            const qs = new URLSearchParams(params).toString();
+            url = `${url}?${qs}`;
+        }
         const resp = await globalThis.fetch(url, {
-            method: "POST",
+            method,
             headers: this.http.headers,
-            body: JSON.stringify(body),
+            body: body !== undefined ? JSON.stringify(body) : undefined,
             signal: AbortSignal.timeout(this.http.timeout),
         });
         if (resp.status >= 400) {
             let detail;
             try {
                 const json = (await resp.json());
-                detail = json.detail ?? resp.statusText;
+                detail = json.detail ?? json.error ?? resp.statusText;
             }
             catch {
                 detail = resp.statusText;
             }
             throw new AgentToolError(`Economy API error (${resp.status}): ${detail}`, {
-                hint: "Check your API key and request parameters.",
+                hint: "Check wallet ID, balance, and spending policy.",
             });
         }
-        return (await resp.json());
+        return resp.json();
+    }
+    // ── Wallets ───────────────────────────────────────────────────────────────
+    /**
+     * Create a new wallet.
+     */
+    async createWallet(options) {
+        const body = { name: options.name };
+        if (options.agentId)
+            body.agentId = options.agentId;
+        if (options.currency)
+            body.currency = options.currency;
+        const r = await this.req("POST", "/v1/wallets", body);
+        return r.data ?? r;
+    }
+    /**
+     * List all wallets for this project.
+     */
+    async listWallets() {
+        const r = await this.req("GET", "/v1/wallets");
+        return r.data ?? r;
+    }
+    /**
+     * Get a wallet by ID.
+     */
+    async getWallet(walletId) {
+        const r = await this.req("GET", `/v1/wallets/${walletId}`);
+        return r.data ?? r;
+    }
+    /**
+     * Fund a wallet with credits.
+     */
+    async fundWallet(walletId, options) {
+        const body = {
+            amount: options.amount,
+            description: options.description ?? "Manual fund",
+        };
+        if (options.metadata)
+            body.metadata = options.metadata;
+        return this.req("POST", `/v1/wallets/${walletId}/fund`, body);
+    }
+    /**
+     * Spend credits from a wallet (subject to spending policy).
+     */
+    async spend(walletId, options) {
+        const body = {
+            amount: options.amount,
+            counterparty: options.counterparty,
+            description: options.description,
+        };
+        if (options.metadata)
+            body.metadata = options.metadata;
+        return this.req("POST", `/v1/wallets/${walletId}/spend`, body);
+    }
+    /**
+     * Set or update a wallet's spending policy.
+     */
+    async setPolicy(walletId, policy) {
+        return this.req("PUT", `/v1/wallets/${walletId}/policy`, policy);
+    }
+    /**
+     * Freeze a wallet — halts all spending immediately.
+     */
+    async freezeWallet(walletId) {
+        const r = await this.req("POST", `/v1/wallets/${walletId}/freeze`);
+        return r.data ?? r;
+    }
+    /**
+     * Unfreeze a wallet to resume normal operation.
+     */
+    async unfreezeWallet(walletId) {
+        const r = await this.req("POST", `/v1/wallets/${walletId}/unfreeze`);
+        return r.data ?? r;
+    }
+    /**
+     * Get paginated transaction history for a wallet.
+     */
+    async getTransactions(walletId, options) {
+        const params = {};
+        if (options?.limit)
+            params.limit = String(options.limit);
+        if (options?.offset)
+            params.offset = String(options.offset);
+        const r = await this.req("GET", `/v1/wallets/${walletId}/transactions`, undefined, Object.keys(params).length ? params : undefined);
+        return r.data ?? r;
+    }
+    // ── Escrows ───────────────────────────────────────────────────────────────
+    /**
+     * Create an escrow — locks credits until work is released or refunded.
+     */
+    async createEscrow(options) {
+        const body = {
+            creatorWalletId: options.creatorWalletId,
+            amount: options.amount,
+            description: options.description,
+        };
+        if (options.workerWalletId)
+            body.workerWalletId = options.workerWalletId;
+        if (options.deadline)
+            body.deadline = options.deadline;
+        const r = await this.req("POST", "/v1/escrows", body);
+        return r.data ?? r;
+    }
+    /**
+     * List escrows, optionally filtered by status.
+     */
+    async listEscrows(status) {
+        const params = status ? { status } : undefined;
+        const r = await this.req("GET", "/v1/escrows", undefined, params);
+        return r.data ?? r;
+    }
+    /**
+     * Get an escrow by ID.
+     */
+    async getEscrow(escrowId) {
+        const r = await this.req("GET", `/v1/escrows/${escrowId}`);
+        return r.data ?? r;
+    }
+    /**
+     * Accept an escrow as the worker.
+     */
+    async acceptEscrow(escrowId, workerWalletId) {
+        const r = await this.req("POST", `/v1/escrows/${escrowId}/accept`, { workerWalletId });
+        return r.data ?? r;
+    }
+    /**
+     * Release escrow funds to the worker.
+     */
+    async releaseEscrow(escrowId) {
+        const r = await this.req("POST", `/v1/escrows/${escrowId}/release`);
+        return r.data ?? r;
+    }
+    /**
+     * Refund escrow credits back to the creator.
+     */
+    async refundEscrow(escrowId) {
+        const r = await this.req("POST", `/v1/escrows/${escrowId}/refund`);
+        return r.data ?? r;
+    }
+    /**
+     * Flag an escrow as disputed — credits stay locked pending resolution.
+     */
+    async disputeEscrow(escrowId) {
+        const r = await this.req("POST", `/v1/escrows/${escrowId}/dispute`);
+        return r.data ?? r;
     }
 }

package/dist/index.d.ts

@@ -12,4 +12,4 @@
 export { AgentTool } from "./client.js";
 export { AgentToolError } from "./errors.js";
 export type { Trace, StoreTraceOptions, SearchTracesOptions, TraceSearchResult, TraceChain } from "./traces.js";
-export type { CreateWalletOptions, ExecuteResult, Memory, ScrapeResult, SearchMemoryOptions, SearchResponse, SearchResult, StoreOptions, UsageStats, VerifyResult, Wallet, } from "./types.js";
+export type { CreateEscrowOptions, CreateWalletOptions, Escrow, ExecuteResult, Memory, ScrapeResult, SearchMemoryOptions, SearchResponse, SearchResult, StoreOptions, UsageStats, VerifyResult, Wallet, WalletPolicy, } from "./types.js";

package/dist/memory.d.ts

@@ -51,6 +51,16 @@ export declare class MemoryClient {
      * @returns UsageStats with current counters.
      */
     usage(): Promise<UsageStats>;
+    /**
+     * Delete a memory by ID.
+     * @param memoryId - UUID of the memory to delete.
+     */
+    delete(memoryId: string): Promise<void>;
+    /**
+     * Delete all memories with a given key.
+     * @param key - The key shared by memories to delete.
+     */
+    deleteByKey(key: string): Promise<void>;
     private post;
     private fetch;
 }

package/dist/memory.js

@@ -79,6 +79,38 @@ export class MemoryClient {
         const resp = await this.fetch("GET", "/v1/usage");
         return resp;
     }
+    /**
+     * Delete a memory by ID.
+     * @param memoryId - UUID of the memory to delete.
+     */
+    async delete(memoryId) {
+        await this.fetch("DELETE", `/v1/memories/${memoryId}`);
+    }
+    /**
+     * Delete all memories with a given key.
+     * @param key - The key shared by memories to delete.
+     */
+    async deleteByKey(key) {
+        const url = `${this.http.baseUrl}/v1/memories?key=${encodeURIComponent(key)}`;
+        const resp = await globalThis.fetch(url, {
+            method: "DELETE",
+            headers: this.http.headers,
+            signal: AbortSignal.timeout(this.http.timeout),
+        });
+        if (resp.status >= 400) {
+            let detail;
+            try {
+                const json = (await resp.json());
+                detail = json.detail ?? resp.statusText;
+            }
+            catch {
+                detail = resp.statusText;
+            }
+            throw new AgentToolError(`Memory API error (${resp.status}): ${detail}`, {
+                hint: "Check your API key and memory key.",
+            });
+        }
+    }
     // --- internal ---
     async post(path, body) {
         return this.fetch("POST", path, body);

package/dist/types.d.ts

@@ -76,9 +76,41 @@ export interface Wallet {
     id: string;
     name: string;
     balance: number;
-    api_key: string;
+    currency: string;
+    frozen: boolean;
+    agentId?: string;
+    createdAt?: string;
 }
 /** Options for creating a wallet. */
 export interface CreateWalletOptions {
     name: string;
+    agentId?: string;
+    currency?: string;
+}
+/** A wallet spending policy. */
+export interface WalletPolicy {
+    maxPerTransaction?: number | null;
+    maxPerHour?: number | null;
+    maxPerDay?: number | null;
+    allowedRecipients?: string[] | null;
+    requiresApprovalAbove?: number | null;
+}
+/** An escrow object. */
+export interface Escrow {
+    id: string;
+    status: "pending" | "active" | "released" | "refunded" | "disputed";
+    amount: number;
+    description: string;
+    creatorWalletId: string;
+    workerWalletId?: string | null;
+    deadline?: string | null;
+    createdAt?: string;
+}
+/** Options for creating an escrow. */
+export interface CreateEscrowOptions {
+    creatorWalletId: string;
+    amount: number;
+    description: string;
+    workerWalletId?: string;
+    deadline?: string;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agenttool/sdk",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "TypeScript SDK for agenttool.dev — memory and tools for AI agents",
   "type": "module",
   "main": "dist/index.js",