@agentsbazaar/sdk 0.2.0 → 0.4.0

package/dist/client.js

@@ -2,9 +2,11 @@ import nacl from "tweetnacl";
 export class AgentBazaarClient {
     baseUrl;
     keypair;
-    constructor(options) {
-        this.baseUrl = (options.baseUrl || "https://agentbazaar.dev").replace(/\/$/, "");
+    apiKey;
+    constructor(options = {}) {
+        this.baseUrl = (options.baseUrl || process.env.AGENTBAZAAR_API || "https://agentbazaar.dev").replace(/\/$/, "");
         this.keypair = options.keypair || null;
+        this.apiKey = options.apiKey || null;
     }
     signMessage(action) {
         if (!this.keypair) {
@@ -21,8 +23,17 @@ export class AgentBazaarClient {
         };
     }
     async request(path, options) {
-        const res = await fetch(`${this.baseUrl}${path}`, options);
-        const data = await res.json();
+        const res = await fetch(`${this.baseUrl}${path}`, {
+            ...options,
+            signal: options?.signal || AbortSignal.timeout(60_000),
+        });
+        let data;
+        try {
+            data = await res.json();
+        }
+        catch {
+            throw new Error(`HTTP ${res.status}: invalid response`);
+        }
         if (!res.ok) {
             throw new Error(data.error || `HTTP ${res.status}`);
         }
@@ -117,7 +128,15 @@ export class AgentBazaarClient {
         return this.request("/health");
     }
     // ── A2A Protocol ──
-    async a2aSend(slug, task) {
+    async a2aSend(slug, task, options) {
+        const parts = [
+            { type: "text", text: task },
+        ];
+        if (options?.files) {
+            for (const f of options.files) {
+                parts.push({ type: "file", url: f.url, name: f.name, mimeType: f.mimeType });
+            }
+        }
         return this.request(`/a2a/${slug}/`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
@@ -125,9 +144,7 @@ export class AgentBazaarClient {
                 jsonrpc: "2.0",
                 id: 1,
                 method: "tasks/send",
-                params: {
-                    message: { parts: [{ type: "text", text: task }] },
-                },
+                params: { message: { parts } },
             }),
         });
     }
@@ -155,43 +172,140 @@ export class AgentBazaarClient {
             }),
         });
     }
-    async *a2aStream(slug, task) {
-        const res = await fetch(`${this.baseUrl}/a2a/${slug}/`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-                jsonrpc: "2.0",
-                id: 1,
-                method: "tasks/sendSubscribe",
-                params: {
-                    message: { parts: [{ type: "text", text: task }] },
-                },
-            }),
-        });
-        if (!res.ok || !res.body) {
-            throw new Error(`A2A stream failed: HTTP ${res.status}`);
+    async *a2aStream(slug, task, options) {
+        const parts = [
+            { type: "text", text: task },
+        ];
+        if (options?.files) {
+            for (const f of options.files) {
+                parts.push({ type: "file", url: f.url, name: f.name, mimeType: f.mimeType });
+            }
         }
-        const reader = res.body.getReader();
-        const decoder = new TextDecoder();
-        let buffer = "";
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split("\n");
-            buffer = lines.pop() || "";
-            for (const line of lines) {
-                if (line.startsWith("data: ")) {
-                    try {
-                        yield JSON.parse(line.slice(6));
-                    }
-                    catch {
-                        // skip malformed events
+        const controller = new AbortController();
+        const timeoutMs = options?.timeoutMs ?? 60_000;
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            const res = await fetch(`${this.baseUrl}/a2a/${slug}/`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    jsonrpc: "2.0",
+                    id: 1,
+                    method: "tasks/sendSubscribe",
+                    params: { message: { parts } },
+                }),
+                signal: controller.signal,
+            });
+            if (!res.ok || !res.body) {
+                throw new Error(`A2A stream failed: HTTP ${res.status}`);
+            }
+            const reader = res.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = "";
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += decoder.decode(value, { stream: true });
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    if (line.startsWith("data: ")) {
+                        try {
+                            yield JSON.parse(line.slice(6));
+                        }
+                        catch {
+                            // skip malformed events
+                        }
                     }
                 }
             }
         }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    // ── Quoting ──
+    async quote(params) {
+        return this.request("/quote", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(params),
+        });
+    }
+    async getQuote(quoteId) {
+        return this.request(`/quote/${quoteId}`);
+    }
+    // ── Sessions ──
+    // ── Sessions — multi-turn conversations ──
+    /**
+     * Start a session with an agent. Returns a sessionId for multi-turn conversations.
+     */
+    async startSession(agentPubkey, budgetLimit) {
+        const auth = this.signMessage("chat");
+        return this.request("/chat/start", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Wallet-Address": auth.address,
+                "X-Wallet-Signature": auth.signature,
+                "X-Wallet-Message": auth.message,
+            },
+            body: JSON.stringify({ agent: agentPubkey, ...(budgetLimit && { budgetLimit }) }),
+        });
+    }
+    /**
+     * Send a message in an existing session. Returns a quote with an unsigned payment transaction.
+     * Call paySession() with the paymentId to execute.
+     */
+    async sendMessage(sessionId, task, fileUrl) {
+        const auth = this.signMessage("chat");
+        return this.request("/chat/send", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Wallet-Address": auth.address,
+                "X-Wallet-Signature": auth.signature,
+                "X-Wallet-Message": auth.message,
+            },
+            body: JSON.stringify({ sessionId, task, ...(fileUrl && { fileUrl }) }),
+        });
+    }
+    /**
+     * Pay for a message and get the agent's response.
+     * Pass the paymentId from sendMessage() and the signed transaction.
+     */
+    async paySession(paymentId, signedTransaction) {
+        const auth = this.signMessage("chat");
+        return this.request("/chat/pay", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Wallet-Address": auth.address,
+                "X-Wallet-Signature": auth.signature,
+                "X-Wallet-Message": auth.message,
+            },
+            body: JSON.stringify({ paymentId, signedTransaction }),
+        });
+    }
+    async listSessions(buyer, status) {
+        const params = new URLSearchParams();
+        if (buyer)
+            params.set("buyer", buyer);
+        if (status)
+            params.set("status", status);
+        const qs = params.toString();
+        return this.request(`/sessions${qs ? `?${qs}` : ""}`, { headers: this.authHeaders("session") });
+    }
+    async getSession(sessionId) {
+        return this.request(`/sessions/${sessionId}`, { headers: this.authHeaders("session") });
+    }
+    async getSessionMessages(sessionId, limit) {
+        const params = limit ? `?limit=${limit}` : "";
+        return this.request(`/sessions/${sessionId}/messages${params}`, { headers: this.authHeaders("session") });
+    }
+    async closeSession(sessionId) {
+        return this.request(`/sessions/${sessionId}/close`, { method: "POST", headers: this.authHeaders("session") });
     }
     // ── Image Upload ──
     async uploadImage(imagePath) {
@@ -210,4 +324,438 @@ export class AgentBazaarClient {
             body: formData,
         });
     }
+    // ── Reviews ──
+    /**
+     * Submit an on-chain review for an agent after a completed job.
+     * The SDK keypair signs as the reviewer, platform pays gas.
+     * For agent-to-agent: the hiring agent's keypair signs the review.
+     */
+    async submitReview(agentPubkey, jobId, score, comment) {
+        const auth = this.signMessage("feedback");
+        // Step 1: Build unsigned tx
+        const buildResult = await this.request("/feedback/build", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Wallet-Address": auth.address,
+                "X-Wallet-Signature": auth.signature,
+                "X-Wallet-Message": auth.message,
+            },
+            body: JSON.stringify({ agentPubkey, jobId, score, comment }),
+        });
+        // Step 2: Sign with SDK keypair
+        const { Transaction } = await import("@solana/web3.js");
+        const txBytes = Buffer.from(buildResult.transaction, "base64");
+        const tx = Transaction.from(txBytes);
+        tx.partialSign(this.keypair);
+        const signedBase64 = tx.serialize({ requireAllSignatures: false }).toString("base64");
+        // Step 3: Submit (platform adds fee payer sig)
+        const auth2 = this.signMessage("feedback");
+        return this.request("/feedback/submit", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Wallet-Address": auth2.address,
+                "X-Wallet-Signature": auth2.signature,
+                "X-Wallet-Message": auth2.message,
+            },
+            body: JSON.stringify({ signedTransaction: signedBase64, jobId, agentPubkey, score, comment }),
+        });
+    }
+    // ── Trust & Reputation ──
+    async getTrustData(pubkey) {
+        return this.request(`/agents/${pubkey}/trust`);
+    }
+    async getLeaderboard(options) {
+        const params = new URLSearchParams();
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        if (options?.minTier !== undefined)
+            params.set("minTier", String(options.minTier));
+        const qs = params.toString();
+        return this.request(`/leaderboard${qs ? `?${qs}` : ""}`);
+    }
+    async getFeedback(pubkey) {
+        return this.request(`/agents/${pubkey}/feedback`);
+    }
+    async revokeFeedback(pubkey, feedbackIndex) {
+        const auth = this.signMessage("feedback");
+        return this.request(`/agents/${pubkey}/feedback/${feedbackIndex}/revoke`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Wallet-Address": auth.address,
+                "X-Wallet-Signature": auth.signature,
+                "X-Wallet-Message": auth.message,
+            },
+        });
+    }
+    async respondToFeedback(pubkey, feedbackIndex, response) {
+        const auth = this.signMessage("feedback");
+        return this.request(`/agents/${pubkey}/feedback/${feedbackIndex}/respond`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Wallet-Address": auth.address,
+                "X-Wallet-Signature": auth.signature,
+                "X-Wallet-Message": auth.message,
+            },
+            body: JSON.stringify({ response }),
+        });
+    }
+    // ── Agent Management ──
+    async updateAgent(params) {
+        const auth = this.signMessage("update");
+        return this.request("/agents/me/metadata", {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Wallet-Address": auth.address,
+                "X-Wallet-Signature": auth.signature,
+                "X-Wallet-Message": auth.message,
+            },
+            body: JSON.stringify(params),
+        });
+    }
+    async transferAgent(newOwner) {
+        const auth = this.signMessage("transfer");
+        return this.request("/agents/me/transfer", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Wallet-Address": auth.address,
+                "X-Wallet-Signature": auth.signature,
+                "X-Wallet-Message": auth.message,
+            },
+            body: JSON.stringify({ newOwner, confirm: true }),
+        });
+    }
+    async setOperationalWallet(wallet, deadline) {
+        const auth = this.signMessage("wallet");
+        return this.request("/agents/me/wallet", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Wallet-Address": auth.address,
+                "X-Wallet-Signature": auth.signature,
+                "X-Wallet-Message": auth.message,
+            },
+            body: JSON.stringify({ operationalWallet: wallet, deadline }),
+        });
+    }
+    async setParentAgent(parentPubkey) {
+        const auth = this.signMessage("parent");
+        return this.request("/agents/me/parent", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Wallet-Address": auth.address,
+                "X-Wallet-Signature": auth.signature,
+                "X-Wallet-Message": auth.message,
+            },
+            body: JSON.stringify({ parentAgent: parentPubkey }),
+        });
+    }
+    async crawlEndpoint(endpoint) {
+        return this.request("/agents/crawl", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ endpoint }),
+        });
+    }
+    // ── Custodial Wallets ──
+    /**
+     * Create a new custodial wallet. Returns an API key — save it, it cannot be recovered.
+     * No keypair needed — this is for users without their own Solana wallet.
+     */
+    static async createWallet(baseUrl, label) {
+        const url = (baseUrl || "https://agentbazaar.dev").replace(/\/$/, "");
+        const res = await fetch(`${url}/wallets/create`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ label }),
+        });
+        const data = await res.json();
+        if (!res.ok)
+            throw new Error(data.error || `HTTP ${res.status}`);
+        return data;
+    }
+    /**
+     * Get wallet info and balance using API key auth.
+     */
+    async getWallet() {
+        if (!this.apiKey)
+            throw new Error("API key required for custodial wallet operations");
+        return this.request("/wallets/me", {
+            headers: { Authorization: `Bearer ${this.apiKey}` },
+        });
+    }
+    /**
+     * Export the private key for the custodial wallet. Returns the full 64-byte keypair.
+     * Save this and import into Phantom/Solflare for self-custody.
+     */
+    async exportKey() {
+        if (!this.apiKey)
+            throw new Error("API key required for custodial wallet operations");
+        return this.request("/wallets/me/export", {
+            headers: { Authorization: `Bearer ${this.apiKey}` },
+        });
+    }
+    // ── Email / Inbox ──
+    /**
+     * List emails in the agent's inbox.
+     */
+    async getInbox(options) {
+        const auth = this.signMessage("inbox");
+        const params = new URLSearchParams();
+        if (options?.limit)
+            params.set("limit", String(options.limit));
+        if (options?.offset)
+            params.set("offset", String(options.offset));
+        const qs = params.toString();
+        return this.request(`/agents/me/inbox${qs ? `?${qs}` : ""}`, {
+            headers: {
+                "X-Wallet-Address": auth.address,
+                "X-Wallet-Signature": auth.signature,
+                "X-Wallet-Message": auth.message,
+            },
+        });
+    }
+    /**
+     * Read a specific email from the agent's inbox.
+     */
+    async readEmail(messageId) {
+        const auth = this.signMessage("inbox");
+        return this.request(`/agents/me/inbox/${encodeURIComponent(messageId)}`, {
+            headers: {
+                "X-Wallet-Address": auth.address,
+                "X-Wallet-Signature": auth.signature,
+                "X-Wallet-Message": auth.message,
+            },
+        });
+    }
+    /**
+     * Send an email from the agent's inbox.
+     */
+    async sendEmail(params) {
+        const auth = this.signMessage("inbox");
+        return this.request("/agents/me/inbox/send", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "X-Wallet-Address": auth.address,
+                "X-Wallet-Signature": auth.signature,
+                "X-Wallet-Message": auth.message,
+            },
+            body: JSON.stringify(params),
+        });
+    }
+    // ── File Upload ──
+    async uploadFile(filePath) {
+        const auth = this.signMessage("upload");
+        const { readFileSync } = await import("fs");
+        const { basename } = await import("path");
+        const buffer = readFileSync(filePath);
+        const fileName = basename(filePath);
+        const formData = new FormData();
+        formData.append("file", new Blob([buffer]), fileName);
+        return this.request("/upload", {
+            method: "POST",
+            headers: {
+                "X-Wallet-Address": auth.address,
+                "X-Wallet-Signature": auth.signature,
+                "X-Wallet-Message": auth.message,
+            },
+            body: formData,
+        });
+    }
+    // ── Private auth helper ──
+    authHeaders(action) {
+        const auth = this.signMessage(action);
+        return {
+            "Content-Type": "application/json",
+            "X-Wallet-Address": auth.address,
+            "X-Wallet-Signature": auth.signature,
+            "X-Wallet-Message": auth.message,
+        };
+    }
+    // ── Platform Credits ──
+    async getCreditBalance() {
+        return this.request("/credits/balance", { headers: this.authHeaders("credits") });
+    }
+    async getCreditHistory(limit) {
+        const qs = limit ? `?limit=${limit}` : "";
+        return this.request(`/credits/history${qs}`, { headers: this.authHeaders("credits") });
+    }
+    async depositCredits(stripePaymentIntentId) {
+        return this.request("/credits/deposit", {
+            method: "POST",
+            headers: this.authHeaders("credits"),
+            body: JSON.stringify({ stripePaymentIntentId }),
+        });
+    }
+    // ── Prepaid Sessions (MPP) ──
+    async createPrepaidSession(agentPubkey, budgetUsdc) {
+        return this.request("/sessions/prepaid", {
+            method: "POST",
+            headers: this.authHeaders("chat"),
+            body: JSON.stringify({ agent: agentPubkey, budgetUsdc }),
+        });
+    }
+    async openPrepaidSession(agentPubkey, budgetUsdc, signedTransaction) {
+        return this.request("/sessions/prepaid", {
+            method: "POST",
+            headers: this.authHeaders("chat"),
+            body: JSON.stringify({ agent: agentPubkey, budgetUsdc, signedTransaction }),
+        });
+    }
+    async extendSession(sessionId, additionalUsdc) {
+        return this.request(`/sessions/${sessionId}/extend`, {
+            method: "POST",
+            headers: this.authHeaders("chat"),
+            body: JSON.stringify({ additionalUsdc }),
+        });
+    }
+    // ── Negotiation ──
+    async sendMessageWithBudget(sessionId, task, maxBudget, fileUrl) {
+        return this.request("/chat/send", {
+            method: "POST",
+            headers: this.authHeaders("chat"),
+            body: JSON.stringify({ sessionId, task, maxBudget, ...(fileUrl && { fileUrl }) }),
+        });
+    }
+    // ── Notifications ──
+    async getNotifications(limit) {
+        const qs = limit ? `?limit=${limit}` : "";
+        return this.request(`/notifications${qs}`, { headers: this.authHeaders("notifications") });
+    }
+    async getUnreadCount() {
+        return this.request("/notifications/unread-count", { headers: this.authHeaders("notifications") });
+    }
+    async markNotificationsRead(ids) {
+        return this.request("/notifications/mark-read", {
+            method: "POST",
+            headers: this.authHeaders("notifications"),
+            body: JSON.stringify({ ids }),
+        });
+    }
+    // ── Webhooks ──
+    async registerWebhook(url, events) {
+        return this.request("/notifications/webhook", {
+            method: "POST",
+            headers: this.authHeaders("webhook"),
+            body: JSON.stringify({ url, events }),
+        });
+    }
+    async getWebhook() {
+        return this.request("/notifications/webhook", { headers: this.authHeaders("webhook") });
+    }
+    async deleteWebhook() {
+        return this.request("/notifications/webhook", {
+            method: "DELETE",
+            headers: this.authHeaders("webhook"),
+        });
+    }
+    // ── Swap / Jupiter ──
+    async getSwapQuote(inputMint, outputMint, amount) {
+        const params = new URLSearchParams({ inputMint, outputMint, amount: String(amount) });
+        return this.request(`/swap/quote?${params}`);
+    }
+    async buildSwapTransaction(inputMint, outputMint, amount) {
+        return this.request("/swap/build", {
+            method: "POST",
+            headers: this.authHeaders("swap"),
+            body: JSON.stringify({ inputMint, outputMint, amount }),
+        });
+    }
+    async getTokenPrice(token) {
+        return this.request(`/swap/price/${token}`);
+    }
+    async getTokenPrices() {
+        return this.request("/swap/prices");
+    }
+    // ── Solana Pay ──
+    async getSolanaPayQR(agentSlug) {
+        return this.request(`/pay/qr/${agentSlug}`);
+    }
+    // ── Blinks ──
+    async getBlink(agentSlug) {
+        return this.request(`/blink/${agentSlug}`);
+    }
+    // ── Recurring Tasks ──
+    async createRecurringTask(params) {
+        return this.request("/recurring/create", {
+            method: "POST",
+            headers: this.authHeaders("recurring"),
+            body: JSON.stringify(params),
+        });
+    }
+    async listRecurringTasks() {
+        return this.request("/recurring", { headers: this.authHeaders("recurring") });
+    }
+    async pauseRecurringTask(id) {
+        return this.request(`/recurring/${id}/pause`, { method: "POST", headers: this.authHeaders("recurring") });
+    }
+    async resumeRecurringTask(id) {
+        return this.request(`/recurring/${id}/resume`, { method: "POST", headers: this.authHeaders("recurring") });
+    }
+    async stopRecurringTask(id) {
+        return this.request(`/recurring/${id}/stop`, { method: "POST", headers: this.authHeaders("recurring") });
+    }
+    // ── Agent Spending ──
+    async getAgentBalance() {
+        return this.request("/agents/actions/balance", { headers: this.authHeaders("balance") });
+    }
+    async getAgentSpendHistory() {
+        return this.request("/agents/spend/history", { headers: this.authHeaders("spend") });
+    }
+    // ── Transactions ──
+    async getTransactionHistory() {
+        return this.request("/transactions/history", { headers: this.authHeaders("transactions") });
+    }
+    // ── Mandates ──
+    async createMandate(params) {
+        return this.request("/mandates/create", {
+            method: "POST",
+            headers: this.authHeaders("mandate"),
+            body: JSON.stringify(params),
+        });
+    }
+    async listMandates() {
+        return this.request("/mandates", { headers: this.authHeaders("mandate") });
+    }
+    async revokeMandate(id) {
+        return this.request(`/mandates/${id}/revoke`, { method: "POST", headers: this.authHeaders("mandate") });
+    }
+    // ── Presigned Upload (large files) ──
+    async getPresignedUploadUrl(fileName, mimeType, size) {
+        return this.request("/upload/presigned", {
+            method: "POST",
+            headers: this.authHeaders("upload"),
+            body: JSON.stringify({ fileName, mimeType, size }),
+        });
+    }
+    async confirmUpload(fileId) {
+        return this.request("/upload/confirm", {
+            method: "POST",
+            headers: this.authHeaders("upload"),
+            body: JSON.stringify({ fileId }),
+        });
+    }
+    // ── Discover ──
+    async discover(skills) {
+        return this.request(`/discover?skills=${encodeURIComponent(skills)}`);
+    }
+    // ── My Agents (owned by wallet or email) ──
+    async myAgents() {
+        return this.request("/agents/my", { headers: this.authHeaders("agents") });
+    }
+    // ── Claim Agent ──
+    async claimAgent(agentPubkey, accessCode) {
+        return this.request("/agents/claim", {
+            method: "POST",
+            headers: this.authHeaders("claim"),
+            body: JSON.stringify({ agentPubkey, accessCode }),
+        });
+    }
 }

package/dist/index.d.ts

@@ -1,2 +1,2 @@
 export { AgentBazaarClient } from "./client.js";
-export { Agent, Job, Rating, PlatformStats, Pagination, AgentCard, RegisterParams, RegisterResult, CallParams, CallResult, HireParams, HireResult, A2ATaskResult, A2AStreamEvent, averageRating, } from "./types.js";
+export { Agent, Job, Rating, PlatformStats, Pagination, AgentCard, RegisterParams, RegisterResult, CallParams, CallResult, HireParams, HireResult, A2ATaskResult, A2AStreamEvent, PaymentRequirements, PaymentReceipt, X402PaymentStatus, FilePart, ArtifactPart, UploadResult, TrustData, TrustTierName, FeedbackEntry, FeedbackResponse, LeaderboardEntry, UpdateAgentParams, TransferResult, CrawlResult, MetadataEntry, SessionInfo, SessionMessage, QuoteParams, QuoteResponse, FileParam, averageRating, } from "./types.js";