@aibtc/mcp-server 1.76.2 → 1.78.0

package/dist/services/taskmarket.service.js

@@ -0,0 +1,100 @@
+/**
+ * TaskMarket service — read-only discovery.
+ *
+ * TaskMarket (https://taskmarket.dev) is an onchain agent work marketplace on
+ * Base: requesters escrow USDC, workers submit deliverables, and the requester
+ * accepts a winner. This service reads the public, anonymous API (search, get,
+ * list-submissions, market-stats). It never signs or spends.
+ */
+const TASKMARKET_API_URL = process.env.TASKMARKET_API_URL || "https://api.taskmarket.dev";
+/** Bound every read so a hung TaskMarket API cannot hold a tool call open. */
+const READ_TIMEOUT_MS = 15_000;
+/** Convert base-unit reward (e.g. "2000000") to human USDC (e.g. "2"). */
+export function baseUnitsToUsdc(raw) {
+    if (!raw || !/^\d+$/.test(raw))
+        return "0";
+    const padded = raw.padStart(7, "0");
+    const whole = padded.slice(0, padded.length - 6) || "0";
+    const frac = padded.slice(padded.length - 6).replace(/0+$/, "");
+    return frac ? `${whole}.${frac}` : whole;
+}
+/** Convert human USDC (e.g. "2") to base units (e.g. "2000000"). */
+export function usdcToBaseUnits(amount) {
+    if (!/^\d+(\.\d+)?$/.test(amount)) {
+        throw new Error(`Invalid USDC amount: "${amount}"`);
+    }
+    const [whole, frac = ""] = amount.split(".");
+    if (frac.length > 6) {
+        throw new Error(`USDC amount has more than 6 decimals: "${amount}"`);
+    }
+    const wholeInt = BigInt(whole || "0");
+    const fracPadded = frac.padEnd(6, "0");
+    const fracInt = fracPadded ? BigInt(fracPadded) : 0n;
+    return (wholeInt * 1000000n + fracInt).toString();
+}
+async function apiGet(path, signal) {
+    const response = await fetch(`${TASKMARKET_API_URL}${path}`, {
+        signal: signal ?? AbortSignal.timeout(READ_TIMEOUT_MS),
+        headers: { accept: "application/json" },
+    });
+    if (!response.ok) {
+        const text = await response.text().catch(() => "Unknown error");
+        throw new Error(`TaskMarket API error ${response.status}: ${text}`);
+    }
+    const json = (await response.json());
+    return (json.data ?? json);
+}
+/**
+ * List/search tasks. Public, anonymous, read-only.
+ */
+export async function listTasks(options) {
+    const params = new URLSearchParams();
+    if (options.status)
+        params.set("status", options.status);
+    if (options.phase)
+        params.set("phase", options.phase);
+    if (options.mode)
+        params.set("mode", options.mode);
+    if (options.tags)
+        params.set("tags", options.tags);
+    if (options.rewardMin)
+        params.set("minReward", usdcToBaseUnits(options.rewardMin));
+    if (options.rewardMax)
+        params.set("maxReward", usdcToBaseUnits(options.rewardMax));
+    params.set("limit", String(options.limit ?? 20));
+    const result = await apiGet(`/api/tasks?${params.toString()}`, options.signal);
+    return {
+        tasks: result.tasks ?? [],
+        hasMore: result.hasMore ?? false,
+        nextCursor: result.nextCursor ?? null,
+    };
+}
+/**
+ * Get a single task with its live status. Public, anonymous, read-only.
+ */
+export async function getTask(taskId, signal) {
+    return apiGet(`/api/tasks/${taskId}`, signal);
+}
+/**
+ * List submissions for a task so the requester can review them for real work.
+ * Public, anonymous, read-only. Never auto-accepts or auto-rejects anything.
+ */
+export async function listSubmissions(taskId, signal) {
+    const result = await apiGet(`/api/tasks/${taskId}/submissions`, signal);
+    if (Array.isArray(result))
+        return result;
+    return (result.submissions ?? []);
+}
+/**
+ * Market/agent statistics. Anonymous read of a public stats endpoint.
+ */
+export async function getMarketStats(options) {
+    const params = new URLSearchParams();
+    if (options.address)
+        params.set("address", options.address);
+    if (options.agentId)
+        params.set("agentId", options.agentId);
+    const query = params.toString();
+    return apiGet(`/api/agents/stats${query ? `?${query}` : ""}`, options.signal);
+}
+//# sourceMappingURL=taskmarket.service.js.map

package/dist/services/x402-post.d.ts

@@ -0,0 +1,50 @@
+import { type AxiosResponse } from "axios";
+import { decodePaymentRequired } from "x402-stacks";
+/** One `accepts` entry of an x402 v2 `payment-required` header. */
+export type X402Accept = NonNullable<ReturnType<typeof decodePaymentRequired>>["accepts"][number];
+export type X402PostResult = {
+    paid: false;
+    status: number;
+    text: string;
+} | {
+    paid: true;
+    response: AxiosResponse;
+    accept: X402Accept;
+    sponsored: boolean;
+    txid?: string;
+    payer?: string;
+};
+/**
+ * True when a failed x402-stacks request had already carried the signed
+ * payment: the retried request's config holds the payment-signature header,
+ * either on the error itself (the retry failed outright) or on its `cause`
+ * (the interceptor's "402 after payment was sent").
+ */
+export declare function paymentWasSent(error: unknown): boolean;
+/**
+ * POST a JSON body to an x402 endpoint, paying the 402 it answers with.
+ *
+ * The endpoint decides who pays gas. When its 402 advertises `extra.feePayer`,
+ * the `x402-stacks` interceptor (`wrapAxiosWithPayment`, >=2.1.0) signs a
+ * sponsored sBTC transfer with fee 0 and the facilitator co-signs and pays the
+ * STX gas; the amount is booked on the spend limiter here, before signing.
+ * Without it, the payment goes through `createApiClient`, which signs a
+ * standard transfer at the `sbtc_transfer` fee clamp (max 0.003 STX) with an
+ * exact-amount post-condition and meters it itself. The SDK's standard path
+ * leaves the fee to stacks.js auto-estimation, which has no ceiling (#700).
+ *
+ * A bare POST never charges, so the first request is a plain-fetch probe that
+ * reads the payment requirements; `beforePay` runs between the probe and the
+ * signature (throw from it to abort, e.g. a balance pre-flight). A 2xx probe
+ * means the endpoint asked for no payment and is returned as-is.
+ */
+export declare function postWithX402Payment(options: {
+    /** Base URL handed to `createApiClient` on the self-paid path. */
+    baseUrl: string;
+    url: string;
+    body: unknown;
+    toolName: string;
+    beforePay?: (accept: X402Accept, sponsored: boolean) => Promise<void>;
+    timeoutMs?: number;
+}): Promise<X402PostResult>;
+//# sourceMappingURL=x402-post.d.ts.map

package/dist/services/x402-post.js

@@ -0,0 +1,107 @@
+import axios from "axios";
+import { wrapAxiosWithPayment, decodePaymentRequired, decodePaymentResponse, X402_HEADERS, } from "x402-stacks";
+import { createApiClient, getAccount, NETWORK } from "./x402.service.js";
+import { getSpendLimiter } from "./spend-limiter.js";
+/**
+ * True when a failed x402-stacks request had already carried the signed
+ * payment: the retried request's config holds the payment-signature header,
+ * either on the error itself (the retry failed outright) or on its `cause`
+ * (the interceptor's "402 after payment was sent").
+ */
+export function paymentWasSent(error) {
+    const carried = (e) => {
+        const headers = e?.config?.headers;
+        if (!headers || typeof headers !== "object")
+            return false;
+        const wanted = X402_HEADERS.PAYMENT_SIGNATURE.toLowerCase();
+        return Object.entries(headers).some(([name, value]) => name.toLowerCase() === wanted && value != null);
+    };
+    return carried(error) || carried(error?.cause);
+}
+/**
+ * POST a JSON body to an x402 endpoint, paying the 402 it answers with.
+ *
+ * The endpoint decides who pays gas. When its 402 advertises `extra.feePayer`,
+ * the `x402-stacks` interceptor (`wrapAxiosWithPayment`, >=2.1.0) signs a
+ * sponsored sBTC transfer with fee 0 and the facilitator co-signs and pays the
+ * STX gas; the amount is booked on the spend limiter here, before signing.
+ * Without it, the payment goes through `createApiClient`, which signs a
+ * standard transfer at the `sbtc_transfer` fee clamp (max 0.003 STX) with an
+ * exact-amount post-condition and meters it itself. The SDK's standard path
+ * leaves the fee to stacks.js auto-estimation, which has no ceiling (#700).
+ *
+ * A bare POST never charges, so the first request is a plain-fetch probe that
+ * reads the payment requirements; `beforePay` runs between the probe and the
+ * signature (throw from it to abort, e.g. a balance pre-flight). A 2xx probe
+ * means the endpoint asked for no payment and is returned as-is.
+ */
+export async function postWithX402Payment(options) {
+    const { baseUrl, url, body, toolName, beforePay } = options;
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    const probe = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(30_000),
+    });
+    if (probe.status !== 402) {
+        const text = await probe.text();
+        if (probe.ok)
+            return { paid: false, status: probe.status, text };
+        throw new Error(`Expected 402 payment challenge, got ${probe.status}: ${text}`);
+    }
+    const paymentRequired = decodePaymentRequired(probe.headers.get(X402_HEADERS.PAYMENT_REQUIRED));
+    if (!paymentRequired?.accepts?.length) {
+        throw new Error("402 response missing or empty payment-required header");
+    }
+    const accept = paymentRequired.accepts[0];
+    // The SDK signs a sponsored (fee 0) transfer exactly when the requirement
+    // names a fee payer — mirror its check.
+    const sponsored = typeof accept.extra?.feePayer === "string";
+    if (beforePay)
+        await beforePay(accept, sponsored);
+    let response;
+    if (sponsored) {
+        const account = await getAccount();
+        // The amount is a signed sBTC spend: book it before signing.
+        const spendLimiter = getSpendLimiter();
+        const reservation = await spendLimiter.reserve([{ unit: "sats", amount: BigInt(accept.amount) }], account.address);
+        const stacksAccount = {
+            address: account.address,
+            privateKey: account.privateKey,
+            network: NETWORK,
+        };
+        // x402-stacks is CJS, so its AxiosInstance comes from axios' .d.cts
+        // types; ours comes from .d.ts. Same runtime object, different type.
+        const api = wrapAxiosWithPayment(axios.create({ timeout: timeoutMs }), stacksAccount);
+        try {
+            response = await api.post(url, body, {
+                headers: { "Content-Type": "application/json" },
+            });
+        }
+        catch (error) {
+            // Once the signed payment rode the retried request, the endpoint may
+            // have settled it, so the booking stands.
+            if (!paymentWasSent(error))
+                await spendLimiter.release(reservation);
+            throw error;
+        }
+    }
+    else {
+        // Self-paid: createApiClient clamps the fee and meters the spend.
+        const api = await createApiClient(baseUrl, { toolName, asset: accept.asset });
+        response = await api.post(url, body, {
+            headers: { "Content-Type": "application/json" },
+        });
+    }
+    const settlement = decodePaymentResponse(response.headers[X402_HEADERS.PAYMENT_RESPONSE]);
+    return {
+        paid: true,
+        response,
+        accept,
+        sponsored,
+        ...(settlement?.transaction && { txid: settlement.transaction }),
+        ...(settlement?.payer && { payer: settlement.payer }),
+    };
+}
+//# sourceMappingURL=x402-post.js.map

package/dist/tools/inbox-auto-reply.tools.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Inbox auto-reply tools.
+ *
+ * - inbox_auto_reply_configure: store enabled / model / systemPrompt / dailyCapSats
+ *   in ~/.aibtc/config.json (no args = show the current settings)
+ * - inbox_auto_reply: answer paid, unanswered inbox messages with a reply
+ *   written by an AIBTC Inference Marketplace model (x402, sBTC), then sign and
+ *   post it to the outbox. Built to be called from an agent's autonomy loop.
+ *
+ * The run logic, ledger and safety rules live in services/inbox-auto-reply.service.ts.
+ */
+import { McpServer } from "@modelcontextprotocol/server";
+export declare function registerInboxAutoReplyTools(server: McpServer): void;
+//# sourceMappingURL=inbox-auto-reply.tools.d.ts.map

package/dist/tools/inbox-auto-reply.tools.js

@@ -0,0 +1,142 @@
+/**
+ * Inbox auto-reply tools.
+ *
+ * - inbox_auto_reply_configure: store enabled / model / systemPrompt / dailyCapSats
+ *   in ~/.aibtc/config.json (no args = show the current settings)
+ * - inbox_auto_reply: answer paid, unanswered inbox messages with a reply
+ *   written by an AIBTC Inference Marketplace model (x402, sBTC), then sign and
+ *   post it to the outbox. Built to be called from an agent's autonomy loop.
+ *
+ * The run logic, ledger and safety rules live in services/inbox-auto-reply.service.ts.
+ */
+import { z } from "zod";
+import { getAccount, NETWORK } from "../services/x402.service.js";
+import { DEFAULT_AUTO_REPLY_MODEL, DEFAULT_DAILY_CAP_SATS, DEFAULT_MAX_REPLIES_PER_RUN, listLiveModels, marketplaceReplyGenerator, runAutoReply, } from "../services/inbox-auto-reply.service.js";
+import { readAppConfig, writeAppConfig } from "../utils/storage.js";
+import { createJsonResponse, createErrorResponse } from "../utils/index.js";
+function requireMainnet() {
+    if (NETWORK !== "mainnet") {
+        throw new Error("Inbox auto-reply is mainnet only: the aibtc.com inbox and the inference marketplace settle in mainnet sBTC. Set NETWORK=mainnet.");
+    }
+}
+export function registerInboxAutoReplyTools(server) {
+    server.registerTool("inbox_auto_reply_configure", {
+        description: "Configure inbox auto-reply (stored in ~/.aibtc/config.json). Call with no arguments to see the current " +
+            "settings. A systemPrompt (the agent's voice / personality / what it can help with) is required before " +
+            "auto-reply can be enabled. The model must be live on inference.aibtc.com; it is checked against the " +
+            "catalog when set. dailyCapSats caps sats spent on reply inference per UTC day, on top of the wallet-wide " +
+            "spending limit.",
+        inputSchema: z.object({
+            enabled: z.boolean().optional().describe("Allow inbox_auto_reply to post replies. Dry runs work while disabled."),
+            model: z
+                .string()
+                .optional()
+                .describe(`Inference marketplace model id (see GET https://inference.aibtc.com/v1/models). Default ${DEFAULT_AUTO_REPLY_MODEL}.`),
+            systemPrompt: z
+                .string()
+                .min(1)
+                .max(4000)
+                .optional()
+                .describe("System prompt for reply generation: who the agent is, its tone, what it offers, what it won't do."),
+            dailyCapSats: z
+                .number()
+                .int()
+                .min(0)
+                .optional()
+                .describe(`Most sats spent on reply inference per UTC day. Default ${DEFAULT_DAILY_CAP_SATS}.`),
+        }),
+    }, async ({ enabled, model, systemPrompt, dailyCapSats }) => {
+        try {
+            const config = await readAppConfig();
+            const current = config.inboxAutoReply;
+            if (enabled === undefined && model === undefined && systemPrompt === undefined && dailyCapSats === undefined) {
+                return createJsonResponse({
+                    configured: Boolean(current),
+                    settings: current ?? null,
+                    ...(!current && {
+                        note: "Not configured. Set at least systemPrompt, then enabled: true.",
+                    }),
+                });
+            }
+            if (model !== undefined) {
+                const live = await listLiveModels();
+                if (!live.includes(model)) {
+                    throw new Error(`Model "${model}" is not live on the inference marketplace. Live models: ${live.join(", ")}`);
+                }
+            }
+            const next = {
+                enabled: enabled ?? current?.enabled ?? false,
+                model: model ?? current?.model ?? DEFAULT_AUTO_REPLY_MODEL,
+                systemPrompt: systemPrompt ?? current?.systemPrompt ?? "",
+                dailyCapSats: dailyCapSats ?? current?.dailyCapSats ?? DEFAULT_DAILY_CAP_SATS,
+            };
+            if (next.enabled && !next.systemPrompt) {
+                throw new Error("Set a systemPrompt before enabling auto-reply.");
+            }
+            await writeAppConfig({ ...config, inboxAutoReply: next });
+            return createJsonResponse({ success: true, settings: next });
+        }
+        catch (error) {
+            return createErrorResponse(error);
+        }
+    });
+    server.registerTool("inbox_auto_reply", {
+        description: "Answer this agent's paid aibtc.com inbox messages automatically. In one call: reads the inbox, picks paid, " +
+            "settled, unanswered messages (oldest first), writes each reply with an AIBTC Inference Marketplace model " +
+            "(paid per request in sBTC via x402, ~1 sat), signs it (BIP-322) and posts it to the outbox (free). " +
+            "Never answers a message twice, stops at the daily cap, and returns a summary: checked, replied, " +
+            "skipped (with reason), failed, inference sats spent and inference cap remaining.\n\n" +
+            "Posting a reply is free; the only cost is the inference call that writes it. " +
+            "Call it from the autonomy loop when the heartbeat or inbox shows unread messages. Configure first with " +
+            "inbox_auto_reply_configure. dryRun writes (and pays for) replies without posting them, so the operator " +
+            "can review the voice. Requires an unlocked wallet with a bc1q address and a little sBTC. Mainnet only.",
+        inputSchema: z.object({
+            maxRepliesPerRun: z
+                .number()
+                .int()
+                .min(1)
+                .max(20)
+                .optional()
+                .describe(`Most messages to answer in this call. Default ${DEFAULT_MAX_REPLIES_PER_RUN}.`),
+            dryRun: z
+                .boolean()
+                .optional()
+                .describe("Generate replies (inference is still paid) but do not post them or mark messages handled."),
+        }),
+    }, async ({ maxRepliesPerRun, dryRun }) => {
+        try {
+            requireMainnet();
+            const config = (await readAppConfig()).inboxAutoReply;
+            if (!config?.systemPrompt) {
+                throw new Error("Inbox auto-reply is not configured. Call inbox_auto_reply_configure with a systemPrompt first.");
+            }
+            const isDryRun = dryRun ?? false;
+            if (!config.enabled && !isDryRun) {
+                throw new Error("Inbox auto-reply is disabled. Enable it with inbox_auto_reply_configure { enabled: true }, or pass dryRun: true to preview replies.");
+            }
+            const account = await getAccount();
+            const summary = await runAutoReply({
+                account,
+                systemPrompt: config.systemPrompt,
+                dailyCapSats: config.dailyCapSats,
+                maxRepliesPerRun: maxRepliesPerRun ?? DEFAULT_MAX_REPLIES_PER_RUN,
+                dryRun: isDryRun,
+                generator: marketplaceReplyGenerator(config.model),
+            });
+            return createJsonResponse({
+                success: summary.failed.length === 0,
+                dryRun: isDryRun,
+                model: config.model,
+                ...summary,
+                repliedCount: summary.replied.length,
+                skippedCount: summary.skipped.length,
+                failedCount: summary.failed.length,
+                dailyCapSats: config.dailyCapSats,
+            });
+        }
+        catch (error) {
+            return createErrorResponse(error);
+        }
+    });
+}
+//# sourceMappingURL=inbox-auto-reply.tools.js.map

package/dist/tools/inbox-x402.tools.d.ts

@@ -9,13 +9,8 @@ export declare function checkDirectInboxBalance(address: string, amount: string,
  * x402 inbox messaging. The transaction is signed but not broadcast; the
  * inbox endpoint settles it through its x402 facilitator.
  *
- * The inbox decides who pays gas. When its 402 advertises `extra.feePayer`,
- * the `x402-stacks` interceptor (`wrapAxiosWithPayment`, >=2.1.0) signs a
- * sponsored sBTC transfer with fee 0 and the facilitator co-signs and pays the
- * STX gas. Without it, the payment goes through `createApiClient`, which signs
- * a standard transfer at the `sbtc_transfer` fee clamp (max 0.003 STX) with an
- * exact-amount post-condition. The SDK's standard path leaves the fee to
- * stacks.js auto-estimation, which has no ceiling (#700).
+ * The inbox decides who pays gas (402 `extra.feePayer`); the sponsored and
+ * self-paid paths live in `postWithX402Payment` (`services/x402-post.ts`).
  *
  * Server side: `lib/inbox/x402-verify.ts` deserializes the payment tx and
  * branches on `tx.auth.authType` (sponsored → relay sponsors; standard →

package/dist/tools/inbox-x402.tools.js

@@ -1,8 +1,7 @@
 import { z } from "zod";
-import axios, { AxiosError } from "axios";
-import { wrapAxiosWithPayment, decodePaymentRequired, decodePaymentResponse, X402_HEADERS, } from "x402-stacks";
-import { createApiClient, getAccount, NETWORK } from "../services/x402.service.js";
-import { getSpendLimiter } from "../services/spend-limiter.js";
+import { AxiosError } from "axios";
+import { getAccount, NETWORK } from "../services/x402.service.js";
+import { postWithX402Payment } from "../services/x402-post.js";
 import { getSbtcService } from "../services/sbtc.service.js";
 import { getHiroApi } from "../services/hiro-api.js";
 import { getExplorerTxUrl } from "../config/networks.js";
@@ -56,33 +55,12 @@ export async function checkDirectInboxBalance(address, amount, sponsored = false
             `This send requires STX for gas — deposit STX to cover the transfer fee.`, "STX", stxBalance.toString(), feeBudget.toString(), shortfall.toString());
     }
 }
-/**
- * True when a failed x402-stacks request had already carried the signed
- * payment: the retried request's config holds the payment-signature header,
- * either on the error itself (the retry failed outright) or on its `cause`
- * (the interceptor's "402 after payment was sent").
- */
-function paymentWasSent(error) {
-    const carried = (e) => {
-        const headers = e?.config?.headers;
-        if (!headers || typeof headers !== "object")
-            return false;
-        const wanted = X402_HEADERS.PAYMENT_SIGNATURE.toLowerCase();
-        return Object.entries(headers).some(([name, value]) => name.toLowerCase() === wanted && value != null);
-    };
-    return carried(error) || carried(error?.cause);
-}
 /**
  * x402 inbox messaging. The transaction is signed but not broadcast; the
  * inbox endpoint settles it through its x402 facilitator.
  *
- * The inbox decides who pays gas. When its 402 advertises `extra.feePayer`,
- * the `x402-stacks` interceptor (`wrapAxiosWithPayment`, >=2.1.0) signs a
- * sponsored sBTC transfer with fee 0 and the facilitator co-signs and pays the
- * STX gas. Without it, the payment goes through `createApiClient`, which signs
- * a standard transfer at the `sbtc_transfer` fee clamp (max 0.003 STX) with an
- * exact-amount post-condition. The SDK's standard path leaves the fee to
- * stacks.js auto-estimation, which has no ceiling (#700).
+ * The inbox decides who pays gas (402 `extra.feePayer`); the sponsored and
+ * self-paid paths live in `postWithX402Payment` (`services/x402-post.ts`).
  *
  * Server side: `lib/inbox/x402-verify.ts` deserializes the payment tx and
  * branches on `tx.auth.authType` (sponsored → relay sponsors; standard →
@@ -126,77 +104,24 @@ export function registerInboxX402Tools(server) {
                 toStxAddress: recipientStxAddress,
                 content,
             };
-            // Step 1: Probe for the 402 challenge (no payment) so we can pre-check
-            // balance before signing. A bare POST never charges — it just returns
-            // the payment requirements. We use plain fetch here so the x402-stacks
-            // interceptor does not auto-pay this probe.
-            const probe = await fetch(inboxUrl, {
-                method: "POST",
-                headers: { "Content-Type": "application/json" },
-                body: JSON.stringify(body),
-                signal: AbortSignal.timeout(30_000),
+            // Probe for the 402, pre-flight the balance (sBTC for the message, plus
+            // a realistic STX gas budget when the sender pays its own fee), then pay.
+            const result = await postWithX402Payment({
+                baseUrl: INBOX_BASE,
+                url: inboxUrl,
+                body,
+                toolName: "send_inbox_message_direct",
+                beforePay: (accept, sponsored) => checkDirectInboxBalance(account.address, accept.amount, sponsored),
+                timeoutMs: 120_000,
             });
-            if (probe.status !== 402) {
-                const text = await probe.text();
-                if (probe.ok) {
-                    return createJsonResponse({
-                        success: true,
-                        message: "Message sent (no payment required)",
-                        response: text,
-                    });
-                }
-                throw new Error(`Expected 402 payment challenge, got ${probe.status}: ${text}`);
-            }
-            const paymentRequired = decodePaymentRequired(probe.headers.get(X402_HEADERS.PAYMENT_REQUIRED));
-            if (!paymentRequired?.accepts?.length) {
-                throw new Error("402 response missing or empty payment-required header");
-            }
-            const accept = paymentRequired.accepts[0];
-            // The SDK signs a sponsored (fee 0) transfer exactly when the
-            // requirement names a fee payer — mirror its check.
-            const sponsored = typeof accept.extra?.feePayer === "string";
-            // Step 2: Pre-flight balance check — sBTC for the message, plus a
-            // realistic STX gas budget when the sender pays its own fee.
-            await checkDirectInboxBalance(account.address, accept.amount, sponsored);
-            // Step 3: Send. Either interceptor handles 402 -> sign -> retry.
-            let response;
-            if (sponsored) {
-                // The message cost is a signed sBTC spend: book it before signing.
-                const spendLimiter = getSpendLimiter();
-                const reservation = await spendLimiter.reserve([{ unit: "sats", amount: BigInt(accept.amount) }], account.address);
-                const stacksAccount = {
-                    address: account.address,
-                    privateKey: account.privateKey,
-                    network: NETWORK,
-                };
-                const api = wrapAxiosWithPayment(axios.create({ timeout: 120_000 }), stacksAccount);
-                try {
-                    response = await api.post(inboxUrl, body, {
-                        headers: { "Content-Type": "application/json" },
-                    });
-                }
-                catch (error) {
-                    // Once the signed payment rode the retried request, the inbox may
-                    // have settled it, so the booking stands.
-                    if (!paymentWasSent(error))
-                        await spendLimiter.release(reservation);
-                    throw error;
-                }
-            }
-            else {
-                // Self-paid: createApiClient clamps the fee and meters the spend.
-                const api = await createApiClient(INBOX_BASE, {
-                    toolName: "send_inbox_message_direct",
-                    asset: accept.asset,
-                });
-                response = await api.post(inboxUrl, body, {
-                    headers: { "Content-Type": "application/json" },
+            if (!result.paid) {
+                return createJsonResponse({
+                    success: true,
+                    message: "Message sent (no payment required)",
+                    response: result.text,
                 });
             }
-            // Step 4: Decode the settlement (txid + payer) from the response header.
-            const settlement = decodePaymentResponse(response.headers[X402_HEADERS.PAYMENT_RESPONSE]);
-            const txid = settlement?.transaction;
-            const payer = settlement?.payer;
+            const { response, accept, sponsored, txid, payer } = result;
             return createJsonResponse({
                 success: true,
                 message: sponsored

package/dist/tools/index.js

@@ -50,8 +50,10 @@ import { registerBountyScannerTools } from "./bounty-scanner.tools.js";
 import { registerRunesTools } from "./runes.tools.js";
 import { registerInboxTools } from "./inbox.tools.js";
 import { registerInboxX402Tools } from "./inbox-x402.tools.js";
+import { registerInboxAutoReplyTools } from "./inbox-auto-reply.tools.js";
 import { registerArxivResearchTools } from "./arxiv-research.tools.js";
 import { registerEarningTools } from "./earning.tools.js";
+import { registerTaskmarketTools } from "./taskmarket.tools.js";
 import { getSkillForTool } from "./skill-mappings.js";
 import { isToolSelected } from "./profiles.js";
 /**
@@ -210,10 +212,14 @@ export function registerAllTools(server, selection) {
     inGroup("social", registerInboxTools);
     // Inbox direct x402 (non-sponsored — sender pays own STX gas, no relay)
     inGroup("social", registerInboxX402Tools);
+    // Inbox auto-reply (answer paid inbox messages with an inference marketplace model)
+    inGroup("social", registerInboxAutoReplyTools);
     // arXiv Research (public arXiv Atom API — paper search and digest compilation)
     inGroup("dev", registerArxivResearchTools);
     // Earning Opportunities (static "how to put your assets to work" menu)
     inGroup("earn", registerEarningTools);
+    // TaskMarket (onchain agent work marketplace on Base — read-only discovery + gated create)
+    inGroup("earn", registerTaskmarketTools);
     restoreRegisterTool();
 }
 //# sourceMappingURL=index.js.map

package/dist/tools/profiles.js

@@ -44,6 +44,9 @@ export const CORE_TOOLS = new Set([
     "bounty_get",
     "bounty_submit",
     "identity_register",
+    // Inbox auto-reply (off until the agent sets a system prompt and enables it)
+    "inbox_auto_reply",
+    "inbox_auto_reply_configure",
 ]);
 export const TOOL_GROUPS = {
     wallet: "Wallet management extras, encrypted credential store",

package/dist/tools/skill-mappings.js

@@ -107,6 +107,8 @@ export const TOOL_SKILL_MAP = {
     openrouter_models: "x402",
     send_inbox_message: "x402",
     send_inbox_message_direct: "x402",
+    inbox_auto_reply: "x402",
+    inbox_auto_reply_configure: "x402",
     // defi skill — ALEX DEX and Zest Protocol
     alex_list_pools: "defi",
     alex_get_swap_quote: "defi",

package/dist/tools/taskmarket.tools.d.ts

@@ -0,0 +1,12 @@
+/**
+ * TaskMarket Tools (https://taskmarket.dev) — onchain agent work marketplace on Base.
+ *
+ * Read tools (public, anonymous, no wallet, no spend):
+ * - taskmarket_search        — list/search open tasks (filters: status, phase, mode, tags, reward)
+ * - taskmarket_get           — full task detail + live status by task ID
+ * - taskmarket_submissions   — list submissions for a task
+ * - taskmarket_stats         — public market/agent statistics
+ */
+import { McpServer } from "@modelcontextprotocol/server";
+export declare function registerTaskmarketTools(server: McpServer): void;
+//# sourceMappingURL=taskmarket.tools.d.ts.map