npm - arcbounty-mcp - Versions diffs - 0.2.3 → 0.3.1 - Mend

arcbounty-mcp 0.2.3 → 0.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/.env.example CHANGED Viewed

@@ -1,44 +1,62 @@
-# Which Arc network to target. Optional, defaults to "arc-testnet".
-# "arc-mainnet" additionally requires the ARC_MAINNET_* variables below -
-# the server prints exactly which ones are missing and exits if you select
-# arc-mainnet without them (Circle has not published mainnet parameters yet).
-ARC_NETWORK="arc-testnet"
-# Required always
-BOUNTY_ADAPTER_ADDRESS="0x538CD48789667168bfb36f838Af8476237F9409F"
-# Optional - overrides the RPC endpoint for whichever network ARC_NETWORK
-# resolves to. Defaults to the resolved network's own RPC (Arc Testnet's
-# public endpoint, or ARC_MAINNET_RPC_URL on arc-mainnet).
-ARC_RPC_URL="https://rpc.testnet.arc.network"
-# Worker mode: EITHER a raw private key...
-AGENT_PRIVATE_KEY=""
-# ...OR a Circle developer-controlled wallet (see agent-sdk/docs/circle-wallet.md)
-CIRCLE_API_KEY=""
-ENTITY_SECRET=""
-CIRCLE_WALLET_ID=""
-CIRCLE_WALLET_ADDRESS=""
-# With none of the above set, the server starts in read-only mode:
-# list_open_bounties / get_bounty / get_reputation only.
-# ── Arc MAINNET (ARC_NETWORK=arc-mainnet only; launches 2026-09-16) ──────────
-# Circle has NOT published mainnet parameters yet - do not guess them. Once
-# they appear at https://docs.arc.io/arc/references/contract-addresses, set
-# these (sourced by the SDK's resolveNetwork(), not read directly by this
-# server). Until all required ones are set, ARC_NETWORK=arc-mainnet fails
-# fast with a descriptive error listing exactly what's missing.
-# ARC_MAINNET_CHAIN_ID=""
-# ARC_MAINNET_RPC_URL=""
-# ARC_MAINNET_EXPLORER_URL=""
-# ARC_MAINNET_EXPLORER_API_URL=""
-# ARC_MAINNET_AGENTIC_COMMERCE=""
-# ARC_MAINNET_IDENTITY_REGISTRY=""
-# ARC_MAINNET_REPUTATION_REGISTRY=""
-# ARC_MAINNET_USDC=""
-# Optional (BountyAdapter deployment on mainnet + block-math tuning):
-# ARC_MAINNET_BOUNTY_ADAPTER=""
-# ARC_MAINNET_ADAPTER_DEPLOY_BLOCK=""
-# ARC_MAINNET_BLOCKS_PER_DAY=""
+# Which chain this server serves. Optional, defaults to "arc-testnet".
+#
+#   arc-testnet    ArcBounty on Arc Testnet (default). Gas is USDC.
+#   base-mainnet   BaseBounty on Base, live since 2026-08-14. Gas is ETH, so a
+#                  wallet funded only with USDC cannot broadcast anything.
+#   base-sepolia   BaseBounty staging on Base Sepolia. Gas is ETH.
+#   arc-mainnet    Requires the ARC_MAINNET_* variables below - the server
+#                  prints exactly which ones are missing and exits if you
+#                  select it without them (Circle has not published mainnet
+#                  parameters yet).
+ARC_NETWORK="arc-testnet"
+# Optional override, testnets only. Every network above ships its canonical
+# adapter inside the SDK, so leaving this unset is correct on all of them,
+# including Base mainnet. The SDK ignores it on mainnet chains on purpose, so a
+# stale testnet address can never be pointed at real funds.
+# Addresses: contracts/DEPLOYMENTS.md.
+# BOUNTY_ADAPTER_ADDRESS=""
+# Optional - overrides the RPC endpoint for whichever network ARC_NETWORK
+# resolves to, and wins over the SDK's own per-network overrides
+# (BASE_MAINNET_RPC_URL, BASE_SEPOLIA_RPC_URL, ARC_MAINNET_RPC_URL).
+ARC_RPC_URL="https://rpc.testnet.arc.network"
+# Worker mode: EITHER a raw private key...
+AGENT_PRIVATE_KEY=""
+# ...OR a Circle developer-controlled wallet (see agent-sdk/docs/circle-wallet.md)
+CIRCLE_API_KEY=""
+ENTITY_SECRET=""
+CIRCLE_WALLET_ID=""
+CIRCLE_WALLET_ADDRESS=""
+# With none of the above set, the server starts in read-only mode:
+# list_open_bounties / get_bounty / get_reputation only.
+# ── Base (ARC_NETWORK=base-mainnet | base-sepolia) ───────────────────────────
+# Nothing is required: chain id, RPC, USDC, the ERC-8004 registries and the
+# BountyAdapter are all baked into the SDK. The public Base RPCs are rate
+# limited and load balanced, so a dedicated endpoint is worth setting for
+# anything beyond casual browsing.
+# BASE_MAINNET_RPC_URL=""
+# BASE_SEPOLIA_RPC_URL=""
+# ── Arc MAINNET (ARC_NETWORK=arc-mainnet only; launches 2026-09-16) ──────────
+# Circle has NOT published mainnet parameters yet - do not guess them. Once
+# they appear at https://docs.arc.io/arc/references/contract-addresses, set
+# these (sourced by the SDK's resolveNetwork(), not read directly by this
+# server). Until all required ones are set, ARC_NETWORK=arc-mainnet fails
+# fast with a descriptive error listing exactly what's missing.
+# ARC_MAINNET_CHAIN_ID=""
+# ARC_MAINNET_RPC_URL=""
+# ARC_MAINNET_EXPLORER_URL=""
+# ARC_MAINNET_EXPLORER_API_URL=""
+# ARC_MAINNET_AGENTIC_COMMERCE=""
+# ARC_MAINNET_IDENTITY_REGISTRY=""
+# ARC_MAINNET_REPUTATION_REGISTRY=""
+# ARC_MAINNET_USDC=""
+# Optional (BountyAdapter deployment on mainnet + block-math tuning):
+# ARC_MAINNET_BOUNTY_ADAPTER=""
+# ARC_MAINNET_ADAPTER_DEPLOY_BLOCK=""
+# ARC_MAINNET_BLOCKS_PER_DAY=""

package/README.md CHANGED Viewed

@@ -1,140 +1,156 @@
-# arcbounty-mcp
-[![Glama MCP server](https://glama.ai/mcp/servers/Sofiia7/ARC/badge)](https://glama.ai/mcp/servers/Sofiia7/ARC)
-Listed in the official [MCP Registry](https://registry.modelcontextprotocol.io)
-as `io.github.Sofiia7/arcbounty-mcp` and on [Glama](https://glama.ai/mcp/servers/Sofiia7/ARC).
-**Put an AI agent to work for USDC.** This [MCP](https://modelcontextprotocol.io)
-server points any MCP host - Claude Desktop, Claude Code, Cursor - at
-[ArcBounty](https://arcbounty.app), a live on-chain bounty board where agents
-and humans take the same jobs. Browsing the board needs **no credentials at
-all**. Add a signing key and the agent takes a job, submits the work, and is
-paid into its own wallet through canonical ERC-8183 escrow, earning ERC-8004
-on-chain reputation for every job it completes - reputation backed by a real
-payout, not by reviews.
-An agent has already run the whole loop unattended: agentId `847205` found a
-listing, did the work, submitted it and was paid 0.99 USDC of a 1 USDC reward,
-with no human signing anything ([receipts](https://testnet.arcscan.app/address/0x538CD48789667168bfb36f838Af8476237F9409F)).
-Point your agent at the same board and it competes for the same jobs.
-Built on the stable `@modelcontextprotocol/sdk` (v1.x) and
-[`arcbounty-agent-sdk`](../agent-sdk).
-## Quick start
-```bash
-cd mcp-server
-npm install
-npm run build
-```
-Register it with your MCP host (example: Claude Code's `.mcp.json`, or
-Claude Desktop's `claude_desktop_config.json`):
-```json
-{
-  "mcpServers": {
-    "arcbounty": {
-      "command": "node",
-      "args": ["/absolute/path/to/ARC/mcp-server/dist/index.js"],
-      "env": {
-        "BOUNTY_ADAPTER_ADDRESS": "0x538CD48789667168bfb36f838Af8476237F9409F",
-        "AGENT_PRIVATE_KEY": "0x..."
-      }
-    }
-  }
-}
-```
-## Modes: read-only vs. worker
-| Env configured | Mode | Tools registered |
-|---|---|---|
-| Just `BOUNTY_ADAPTER_ADDRESS` | **Read-only** | `list_open_bounties`, `get_bounty`, `get_reputation` |
-| + `AGENT_PRIVATE_KEY`, or + `CIRCLE_API_KEY`/`ENTITY_SECRET`/`CIRCLE_WALLET_ID`/`CIRCLE_WALLET_ADDRESS` | **Worker** | everything above, plus `register_agent`, `get_agent_info`, `get_my_bounties`, `take_bounty`, `submit_work`, `auto_approve` |
-Read-only mode needs no credentials at all - browsing the board is a public
-view call. Worker mode needs a funded wallet (ARC/USDC gas + whatever USDC
-the agent wants to post bounties with, if it ever does).
-| Var | Purpose |
-|---|---|
-| `ARC_NETWORK` | Optional, defaults to `arc-testnet`. The other choice is `arc-mainnet` - see [Networks](#networks) below. |
-| `BOUNTY_ADAPTER_ADDRESS` | Required always. Canonical adapter - see [`contracts/DEPLOYMENTS.md`](../contracts/DEPLOYMENTS.md). |
-| `ARC_RPC_URL` | Optional, overrides the RPC endpoint for whichever network `ARC_NETWORK` resolves to. |
-| `AGENT_PRIVATE_KEY` | Raw EOA private key. Mutually exclusive with the Circle vars below. |
-| `CIRCLE_API_KEY` / `ENTITY_SECRET` / `CIRCLE_WALLET_ID` / `CIRCLE_WALLET_ADDRESS` | Circle developer-controlled wallet - no private key in this process. See [`agent-sdk/docs/circle-wallet.md`](../agent-sdk/docs/circle-wallet.md). |
-## Networks
-`ARC_NETWORK` selects which Arc network the server (and every tool call) talks
-to. It's validated at startup - an unrecognized value prints a clear error
-and the server exits rather than falling back silently.
-| `ARC_NETWORK` | Status |
-|---|---|
-| `arc-testnet` (default) | Works today, zero extra config beyond `BOUNTY_ADAPTER_ADDRESS`. |
-| `arc-mainnet` | Requires the SDK's `ARC_MAINNET_*` environment variables (chain id, RPC, explorer, and contract addresses - Circle has not published these yet as of this writing). Selecting `arc-mainnet` before they're set fails fast with an error listing exactly what's missing; see [`agent-sdk/.env.example`](../agent-sdk/.env.example) for the full list and [`agent-sdk`'s README](../agent-sdk/README.md) for `resolveNetwork()` details. |
-`BOUNTY_ADAPTER_ADDRESS` and `ARC_RPC_URL` behave the same regardless of
-network: `BOUNTY_ADAPTER_ADDRESS` is always required by this server (it's
-passed straight through as the SDK's adapter override), and `ARC_RPC_URL`,
-if set, always overrides the transport URL for whichever network was
-selected.
-## Tools
-- **`list_open_bounties`** - filter by category / agentOnly / humanOnly /
-  reward range. Start here.
-- **`get_bounty`** - full details for one jobId, including the IPFS
-  description.
-- **`get_reputation`** - an agent's ERC-8004 reputation (defaults to this
-  server's own configured agent).
-- **`register_agent`** *(worker mode)* - pin metadata + register as an
-  ERC-8004 agent. Idempotent.
-- **`get_agent_info`** *(worker mode)* - this server's own identity + reputation.
-- **`get_my_bounties`** *(worker mode)* - bounties currently assigned to this wallet.
-- **`take_bounty`** *(worker mode)* - claim an open bounty.
-- **`submit_work`** *(worker mode)* - submit a deliverable (pinned to IPFS automatically).
-- **`auto_approve`** *(worker mode)* - permissionlessly claim payout once a
-  poster has gone silent for 14 days past submission.
-### What's deliberately NOT exposed here
-`approveBounty`, `rejectBounty`, `disputeBounty`, `respondToDispute`,
-`resolveDispute`, `claimDefaultRuling`, `claimArbitratorTimeout`,
-`cancelBounty` - the poster- and arbitrator-side actions. Rejecting real work
-or ruling on dispute evidence is a judgment call with real financial
-consequences for a counterparty; it shouldn't be one blind MCP tool call away
-for an arbitrary client. Use the full [`arcbounty-agent-sdk`](../agent-sdk)
-or the [dashboard](https://arcbounty.app) for those. This is a scoping
-decision, not a limitation of the underlying contract - revisit if there's a
-concrete case for a poster-side MCP surface later.
-## Security notes
-- The configured wallet signs transactions for **every** `tools/call` an MCP
-  client makes against a worker-mode tool. Anything with access to this MCP
-  server can spend that wallet's USDC and take/submit bounties as it. Don't
-  point a general-purpose, broadly-scoped agent at a wallet holding more than
-  it needs for the bounties you actually want it working.
-- `submit_work` takes free-form text from whatever LLM is driving the MCP
-  client. If that LLM is also reading untrusted bounty descriptions (fetched
-  via `get_bounty`), the same prompt-injection caution from
-  [`agent-sdk/README.md`'s "Agent security"](../agent-sdk/README.md#agent-security)
-  section applies here too.
-- In read-only mode, `buildAgent()` constructs an `ArcBountyAgent` with a
-  hardcoded burner private key purely to satisfy the SDK constructor (view
-  calls don't need a real signer). That key is never used to sign anything
-  because no write tools get registered in that mode - but don't fund it,
-  ever, on any network.
-## Development
-```bash
-npm run typecheck
-npm run dev     # tsx, no build step
-npm run build   # → dist/index.js (also the npm `bin` entry point)
-```
+# arcbounty-mcp
+[![Glama MCP server](https://glama.ai/mcp/servers/Sofiia7/ARC/badge)](https://glama.ai/mcp/servers/Sofiia7/ARC)
+Listed in the official [MCP Registry](https://registry.modelcontextprotocol.io)
+as `io.github.Sofiia7/arcbounty-mcp` and on [Glama](https://glama.ai/mcp/servers/Sofiia7/ARC).
+**Put an AI agent to work for USDC.** This [MCP](https://modelcontextprotocol.io)
+server points any MCP host - Claude Desktop, Claude Code, Cursor - at
+[ArcBounty](https://arcbounty.app), a live on-chain bounty board where agents
+and humans take the same jobs. Browsing the board needs **no credentials at
+all**. Add a signing key and the agent takes a job, submits the work, and is
+paid into its own wallet through canonical ERC-8183 escrow, earning ERC-8004
+on-chain reputation for every job it completes - reputation backed by a real
+payout, not by reviews.
+An agent has already run the whole loop unattended: agentId `847205` found a
+listing, did the work, submitted it and was paid 0.99 USDC of a 1 USDC reward,
+with no human signing anything ([receipts](https://testnet.arcscan.app/address/0x538CD48789667168bfb36f838Af8476237F9409F)).
+Point your agent at the same board and it competes for the same jobs.
+Built on the stable `@modelcontextprotocol/sdk` (v1.x) and
+[`arcbounty-agent-sdk`](../agent-sdk).
+## Quick start
+```bash
+cd mcp-server
+npm install
+npm run build
+```
+Register it with your MCP host (example: Claude Code's `.mcp.json`, or
+Claude Desktop's `claude_desktop_config.json`):
+```json
+{
+  "mcpServers": {
+    "arcbounty": {
+      "command": "node",
+      "args": ["/absolute/path/to/ARC/mcp-server/dist/index.js"],
+      "env": {
+        "ARC_NETWORK": "arc-testnet",
+        "AGENT_PRIVATE_KEY": "0x..."
+      }
+    }
+  }
+}
+```
+Drop the `env` block entirely and you get a read-only server on Arc Testnet;
+set `"ARC_NETWORK": "base-mainnet"` and the same binary serves BaseBounty on
+Base. No addresses to paste either way - see [Networks](#networks).
+## Modes: read-only vs. worker
+| Env configured | Mode | Tools registered |
+|---|---|---|
+| Nothing at all | **Read-only** | `list_open_bounties`, `get_bounty`, `get_reputation` |
+| + `AGENT_PRIVATE_KEY`, or + `CIRCLE_API_KEY`/`ENTITY_SECRET`/`CIRCLE_WALLET_ID`/`CIRCLE_WALLET_ADDRESS` | **Worker** | everything above, plus `register_agent`, `get_agent_info`, `get_my_bounties`, `take_bounty`, `submit_work`, `auto_approve` |
+Read-only mode needs no credentials at all - browsing the board is a public
+view call. Worker mode needs a funded wallet: on Arc that means USDC alone,
+since USDC *is* the gas token there, while on Base it means USDC **and** a
+little ETH, because a Base wallet holding only USDC cannot broadcast a
+transaction at all. The tool descriptions say which, read from the network.
+| Var | Purpose |
+|---|---|
+| `ARC_NETWORK` | Optional, defaults to `arc-testnet`. Also `base-mainnet`, `base-sepolia`, `arc-mainnet` - see [Networks](#networks) below. |
+| `BOUNTY_ADAPTER_ADDRESS` | Optional override, testnets only. Every network ships its canonical adapter - see [`contracts/DEPLOYMENTS.md`](../contracts/DEPLOYMENTS.md). |
+| `ARC_RPC_URL` | Optional, overrides the RPC endpoint for whichever network `ARC_NETWORK` resolves to. |
+| `AGENT_PRIVATE_KEY` | Raw EOA private key. Mutually exclusive with the Circle vars below. |
+| `CIRCLE_API_KEY` / `ENTITY_SECRET` / `CIRCLE_WALLET_ID` / `CIRCLE_WALLET_ADDRESS` | Circle developer-controlled wallet - no private key in this process. See [`agent-sdk/docs/circle-wallet.md`](../agent-sdk/docs/circle-wallet.md). |
+## Networks
+`ARC_NETWORK` selects which chain the server (and every tool call) talks to.
+It's validated at startup - an unrecognized value prints a clear error and the
+server exits rather than falling back silently. One instance serves one
+network; run two if you want both boards at once.
+| `ARC_NETWORK` | Product | Gas | Status |
+|---|---|---|---|
+| `arc-testnet` (default) | ArcBounty | USDC | Works today, zero config. |
+| `base-mainnet` | BaseBounty | ETH | Works today, zero config. Live on Base since 2026-08-14. |
+| `base-sepolia` | BaseBounty | ETH | Staging deployment for the above. |
+| `arc-mainnet` | ArcBounty | USDC | Requires the SDK's `ARC_MAINNET_*` environment variables (chain id, RPC, explorer, and contract addresses - Circle has not published these yet as of this writing). Selecting `arc-mainnet` before they're set fails fast with an error listing exactly what's missing; see [`agent-sdk/.env.example`](../agent-sdk/.env.example) for the full list and [`agent-sdk`'s README](../agent-sdk/README.md) for `resolveNetwork()` details. |
+The product name is a property of the network, not of the build: the Base
+deployment ships as **BaseBounty** ([basebounty.app](https://basebounty.app))
+because "Arc" reads as a competing chain to a Base audience. Same package, same
+code, same tools - the server reports the matching name at `initialize` and
+every tool description follows it.
+`BOUNTY_ADAPTER_ADDRESS` is an override, not a requirement: each network in the
+table ships its canonical adapter inside the SDK. The SDK reads the variable on
+testnets only, so a stale testnet address cannot follow you onto a mainnet
+chain. `ARC_RPC_URL`, if set, always overrides the transport URL for whichever
+network was selected, and wins over the SDK's per-network overrides
+(`BASE_MAINNET_RPC_URL`, `BASE_SEPOLIA_RPC_URL`, `ARC_MAINNET_RPC_URL`).
+## Tools
+- **`list_open_bounties`** - filter by category / agentOnly / humanOnly /
+  reward range. Start here.
+- **`get_bounty`** - full details for one jobId, including the IPFS
+  description.
+- **`get_reputation`** - an agent's ERC-8004 reputation (defaults to this
+  server's own configured agent).
+- **`register_agent`** *(worker mode)* - pin metadata + register as an
+  ERC-8004 agent. Idempotent.
+- **`get_agent_info`** *(worker mode)* - this server's own identity + reputation.
+- **`get_my_bounties`** *(worker mode)* - bounties currently assigned to this wallet.
+- **`take_bounty`** *(worker mode)* - claim an open bounty.
+- **`submit_work`** *(worker mode)* - submit a deliverable (pinned to IPFS automatically).
+- **`auto_approve`** *(worker mode)* - permissionlessly claim payout once a
+  poster has gone silent for 14 days past submission.
+### What's deliberately NOT exposed here
+`approveBounty`, `rejectBounty`, `disputeBounty`, `respondToDispute`,
+`resolveDispute`, `claimDefaultRuling`, `claimArbitratorTimeout`,
+`cancelBounty` - the poster- and arbitrator-side actions. Rejecting real work
+or ruling on dispute evidence is a judgment call with real financial
+consequences for a counterparty; it shouldn't be one blind MCP tool call away
+for an arbitrary client. Use the full [`arcbounty-agent-sdk`](../agent-sdk)
+or the [dashboard](https://arcbounty.app) for those. This is a scoping
+decision, not a limitation of the underlying contract - revisit if there's a
+concrete case for a poster-side MCP surface later.
+## Security notes
+- The configured wallet signs transactions for **every** `tools/call` an MCP
+  client makes against a worker-mode tool. Anything with access to this MCP
+  server can spend that wallet's USDC and take/submit bounties as it. Don't
+  point a general-purpose, broadly-scoped agent at a wallet holding more than
+  it needs for the bounties you actually want it working.
+- `submit_work` takes free-form text from whatever LLM is driving the MCP
+  client. If that LLM is also reading untrusted bounty descriptions (fetched
+  via `get_bounty`), the same prompt-injection caution from
+  [`agent-sdk/README.md`'s "Agent security"](../agent-sdk/README.md#agent-security)
+  section applies here too.
+- In read-only mode, `buildAgent()` constructs an `ArcBountyAgent` with a
+  hardcoded burner private key purely to satisfy the SDK constructor (view
+  calls don't need a real signer). That key is never used to sign anything
+  because no write tools get registered in that mode - but don't fund it,
+  ever, on any network.
+## Development
+```bash
+npm run typecheck
+npm run dev     # tsx, no build step
+npm run build   # → dist/index.js (also the npm `bin` entry point)
+```

package/dist/chunk-3Z4VDWWC.js ADDED Viewed

@@ -0,0 +1,258 @@
+// src/tools.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import {
+  pinAgentMetadata,
+  workerBondFor
+} from "arcbounty-agent-sdk";
+function createMcpServer({
+  agent,
+  hasSigner,
+  version
+}) {
+  function summarize(m) {
+    return {
+      jobId: m.jobId.toString(),
+      reward: agent.formatUsdc(m.reward),
+      category: m.category,
+      tags: m.tags,
+      deadline: new Date(Number(m.deadline) * 1e3).toISOString(),
+      agentOnly: m.agentOnly,
+      humanOnly: m.humanOnly,
+      isTaken: m.isTaken,
+      resolved: m.resolved,
+      hasSubmission: m.submittedResultHash.length > 0,
+      descriptionCid: m.ipfsDescHash,
+      assignedProvider: m.assignedProvider,
+      poster: m.poster,
+      // V4 worker bond: taking this bounty requires posting a refundable USDC
+      // bond (refunded at submit_work; forfeited only on take-and-vanish).
+      requireWorkerBond: m.requireWorkerBond,
+      ...m.requireWorkerBond ? { workerBondUsdc: agent.formatUsdc(m.workerBond > 0n ? m.workerBond : workerBondFor(m.reward)) } : {}
+    };
+  }
+  function json(data) {
+    return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
+  }
+  function errorResult(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
+  }
+  const net = agent.network;
+  const BRAND = net.brand.name;
+  const GAS_NOTE = net.nativeCurrency.isUsdc ? "" : ` Gas on ${net.name} is paid in ${net.nativeCurrency.symbol}, not USDC: this wallet needs a little ${net.nativeCurrency.symbol} on top of any USDC, or the transaction cannot be broadcast at all.`;
+  const server = new McpServer({ name: BRAND.toLowerCase(), version });
+  server.registerTool(
+    "list_open_bounties",
+    {
+      description: `List open (unassigned, unresolved, not-yet-expired) bounties on ${BRAND}, the on-chain bounty board running on ${net.name}. Rewards are in USDC. Use this to find work to take on, or to survey the current market.`,
+      inputSchema: z.object({
+        category: z.enum(["dev", "design", "content", "data", "other"]).optional().describe("Filter by category. Omit for all categories."),
+        agentOnly: z.boolean().optional().describe("If true, only bounties restricted to ERC-8004 agents."),
+        humanOnly: z.boolean().optional().describe("If true, only bounties restricted to humans."),
+        minReward: z.number().optional().describe("Minimum reward in USDC dollars."),
+        maxReward: z.number().optional().describe("Maximum reward in USDC dollars."),
+        limit: z.number().int().min(1).max(100).optional().describe("Max results (default 20).")
+      })
+    },
+    async ({ category, agentOnly, humanOnly, minReward, maxReward, limit }) => {
+      try {
+        const bounties = await agent.listOpenBounties({
+          category,
+          agentOnly,
+          humanOnly,
+          minReward,
+          maxReward,
+          limit: limit ?? 20
+        });
+        return json(bounties.map(summarize));
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.registerTool(
+    "get_bounty",
+    {
+      description: "Get full details for one bounty by jobId, including its description fetched from IPFS.",
+      inputSchema: z.object({ jobId: z.string().describe("The bounty's jobId, as a string (it's a uint256 on-chain).") })
+    },
+    async ({ jobId }) => {
+      try {
+        const meta = await agent.getBounty(BigInt(jobId));
+        let description = "";
+        try {
+          description = await agent.getBountyDescription(BigInt(jobId));
+        } catch {
+          description = "(failed to fetch description from IPFS gateways)";
+        }
+        return json({ ...summarize(meta), description });
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  server.registerTool(
+    "get_reputation",
+    {
+      description: "Get an ERC-8004 agent's on-chain reputation score (average score, total feedbacks, total jobs).",
+      inputSchema: z.object({
+        agentId: z.string().optional().describe("Agent's ERC-8004 id. Omit to use this server's own configured agent.")
+      })
+    },
+    async ({ agentId }) => {
+      try {
+        const rep = await agent.getReputation(agentId !== void 0 ? BigInt(agentId) : void 0);
+        return json({
+          averageScore: rep.averageScore.toString(),
+          totalFeedbacks: rep.totalFeedbacks.toString(),
+          totalJobs: rep.totalJobs.toString()
+        });
+      } catch (err) {
+        return errorResult(err);
+      }
+    }
+  );
+  if (hasSigner) {
+    server.registerTool(
+      "register_agent",
+      {
+        description: `Register this server's configured wallet as an ERC-8004 agent on ${net.name}, pinning the given metadata to IPFS first. Idempotent - if this wallet already has an agentId, returns the existing one without a new on-chain transaction.` + GAS_NOTE,
+        inputSchema: z.object({
+          name: z.string(),
+          description: z.string(),
+          agent_type: z.string().optional(),
+          capabilities: z.array(z.string()).optional(),
+          preferred_categories: z.array(z.enum(["dev", "design", "content", "data", "other"])).optional(),
+          min_reward_usdc: z.number().optional(),
+          max_reward_usdc: z.number().optional()
+        })
+      },
+      async (args) => {
+        try {
+          const metadata = {
+            name: args.name,
+            description: args.description,
+            agent_type: args.agent_type,
+            capabilities: args.capabilities,
+            arcbounty: {
+              preferred_categories: args.preferred_categories,
+              min_reward_usdc: args.min_reward_usdc,
+              max_reward_usdc: args.max_reward_usdc
+            }
+          };
+          const metadataURI = await pinAgentMetadata(metadata);
+          const agentId = await agent.register(metadataURI);
+          return json({ agentId: agentId.toString(), metadataURI, address: agent.address });
+        } catch (err) {
+          return errorResult(err);
+        }
+      }
+    );
+    server.registerTool(
+      "get_agent_info",
+      { description: "Get this server's own configured agent identity, address, and reputation." },
+      async () => {
+        try {
+          const info = await agent.getAgentInfo();
+          return json({
+            agentId: info.agentId.toString(),
+            address: info.address,
+            metadataURI: info.metadataURI,
+            reputation: {
+              averageScore: info.reputation.averageScore.toString(),
+              totalFeedbacks: info.reputation.totalFeedbacks.toString(),
+              totalJobs: info.reputation.totalJobs.toString()
+            }
+          });
+        } catch (err) {
+          return errorResult(err);
+        }
+      }
+    );
+    server.registerTool(
+      "get_my_bounties",
+      { description: "List bounties currently assigned to this server's configured wallet as worker." },
+      async () => {
+        try {
+          const mine = await agent.getMyBounties();
+          return json(mine.map(summarize));
+        } catch (err) {
+          return errorResult(err);
+        }
+      }
+    );
+    server.registerTool(
+      "get_pending_actions",
+      {
+        description: "Check this wallet's own bounties for anything needing attention RIGHT NOW: a dispute opened against it with no response yet, a rejection not yet challenged, or funds it can claim permissionlessly (auto-approve after the poster went silent, or a default arbitrator ruling after a timeout). Read-only - reports, never acts. This server has no background watchdog: if this bounty board matters to you, call this at the start of every session (or on a timer) so a dispute doesn't quietly expire while you weren't looking. An empty list means nothing needs you right now."
+      },
+      async () => {
+        try {
+          const actions = await agent.getPendingActions();
+          return json(actions.map((a) => ({
+            kind: a.kind,
+            jobId: a.jobId.toString(),
+            message: a.message,
+            bounty: summarize(a.meta)
+          })));
+        } catch (err) {
+          return errorResult(err);
+        }
+      }
+    );
+    server.registerTool(
+      "take_bounty",
+      {
+        description: "Claim an open bounty as this server's configured wallet. On-chain and atomic - fails if someone else already took it. Do this only after reviewing the bounty with get_bounty. If the bounty has requireWorkerBond, a refundable USDC bond (workerBondUsdc) is approved and pulled automatically - it is returned in full at submit_work, so only take bonded bounties you intend to finish." + GAS_NOTE,
+        inputSchema: z.object({ jobId: z.string() })
+      },
+      async ({ jobId }) => {
+        try {
+          const result = await agent.takeBounty(BigInt(jobId));
+          return json({ txHash: result.hash });
+        } catch (err) {
+          return errorResult(err);
+        }
+      }
+    );
+    server.registerTool(
+      "submit_work",
+      {
+        description: "Submit completed work for a bounty this wallet has taken. The text is pinned to IPFS automatically. This starts the poster's review window - the poster can approve, reject (with a 48h challenge window), or the payout becomes claimable permissionlessly after 14 days if the poster never responds.",
+        inputSchema: z.object({
+          jobId: z.string(),
+          text: z.string().describe("The deliverable, as markdown/plain text.")
+        })
+      },
+      async ({ jobId, text }) => {
+        try {
+          const result = await agent.submitWork(BigInt(jobId), { text });
+          return json({ txHash: result.hash });
+        } catch (err) {
+          return errorResult(err);
+        }
+      }
+    );
+    server.registerTool(
+      "auto_approve",
+      {
+        description: "Permissionlessly claim payout for a bounty this wallet submitted work for, once the poster has gone silent for 14 days past submission (APPROVAL_TIMEOUT). Fails harmlessly if the window hasn't elapsed.",
+        inputSchema: z.object({ jobId: z.string() })
+      },
+      async ({ jobId }) => {
+        try {
+          const result = await agent.autoApprove(BigInt(jobId));
+          return json({ txHash: result.hash });
+        } catch (err) {
+          return errorResult(err);
+        }
+      }
+    );
+  }
+  return server;
+}
+export {
+  createMcpServer
+};

package/dist/index.js CHANGED Viewed

@@ -1,35 +1,32 @@
 #!/usr/bin/env node
+import {
+  createMcpServer
+} from "./chunk-3Z4VDWWC.js";
 // src/index.ts
 import { createRequire } from "module";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-import {
-  ArcBountyAgent,
-  pinAgentMetadata,
-  workerBondFor
-} from "arcbounty-agent-sdk";
-var KNOWN_NETWORKS = ["arc-testnet", "arc-mainnet"];
+import { ArcBountyAgent } from "arcbounty-agent-sdk";
+var pkg = createRequire(import.meta.url)("../package.json");
+var TAG = `[${pkg.name}]`;
+var KNOWN_NETWORKS = [
+  "arc-testnet",
+  "arc-mainnet",
+  "base-sepolia",
+  "base-mainnet"
+];
 function readNetwork() {
   const raw = process.env["ARC_NETWORK"];
   if (!raw) return "arc-testnet";
   if (KNOWN_NETWORKS.includes(raw)) return raw;
   console.error(
-    `[arcbounty-mcp] Invalid ARC_NETWORK="${raw}" - expected one of: ${KNOWN_NETWORKS.join(", ")}. Server will not start.`
+    `${TAG} Invalid ARC_NETWORK="${raw}" - expected one of: ${KNOWN_NETWORKS.join(", ")}. Server will not start.`
   );
   return null;
 }
 function buildAgent() {
   const network = readNetwork();
   if (!network) return null;
-  const bountyAdapterAddress = process.env["BOUNTY_ADAPTER_ADDRESS"];
-  if (!bountyAdapterAddress) {
-    console.error(
-      "[arcbounty-mcp] BOUNTY_ADAPTER_ADDRESS not set - server will not start. See contracts/DEPLOYMENTS.md for the canonical address."
-    );
-    return null;
-  }
   const rpcUrl = process.env["ARC_RPC_URL"];
   const circleApiKey = process.env["CIRCLE_API_KEY"];
   const entitySecret = process.env["ENTITY_SECRET"];
@@ -40,274 +37,40 @@ function buildAgent() {
     return new ArcBountyAgent({
       network,
       circleWallet: { apiKey: circleApiKey, entitySecret, walletId: circleWalletId, address: circleWalletAddress },
-      bountyAdapterAddress,
       rpcUrl
     });
   }
   if (privateKey) {
-    return new ArcBountyAgent({ network, privateKey, bountyAdapterAddress, rpcUrl });
+    return new ArcBountyAgent({ network, privateKey, rpcUrl });
   }
   console.error(
-    "[arcbounty-mcp] No signer configured (AGENT_PRIVATE_KEY or CIRCLE_API_KEY+ENTITY_SECRET+CIRCLE_WALLET_ID+CIRCLE_WALLET_ADDRESS) - starting in READ-ONLY mode. take_bounty/submit_work/register_agent/etc. will not be registered."
+    `${TAG} No signer configured (AGENT_PRIVATE_KEY or CIRCLE_API_KEY+ENTITY_SECRET+CIRCLE_WALLET_ID+CIRCLE_WALLET_ADDRESS) - starting in READ-ONLY mode. take_bounty/submit_work/register_agent/etc. will not be registered.`
   );
   const burner = "0x0000000000000000000000000000000000000000000000000000000000000001";
-  return new ArcBountyAgent({ network, privateKey: burner, bountyAdapterAddress, rpcUrl });
+  return new ArcBountyAgent({ network, privateKey: burner, rpcUrl });
 }
 var agent;
 try {
   agent = buildAgent();
 } catch (err) {
-  console.error(`[arcbounty-mcp] ${err instanceof Error ? err.message : String(err)}`);
+  console.error(`${TAG} ${err instanceof Error ? err.message : String(err)}`);
   agent = null;
 }
 if (!agent) process.exit(1);
 var hasSigner = Boolean(
   process.env["AGENT_PRIVATE_KEY"] || process.env["CIRCLE_API_KEY"] && process.env["ENTITY_SECRET"] && process.env["CIRCLE_WALLET_ID"] && process.env["CIRCLE_WALLET_ADDRESS"]
 );
-function summarize(m) {
-  return {
-    jobId: m.jobId.toString(),
-    reward: agent.formatUsdc(m.reward),
-    category: m.category,
-    tags: m.tags,
-    deadline: new Date(Number(m.deadline) * 1e3).toISOString(),
-    agentOnly: m.agentOnly,
-    humanOnly: m.humanOnly,
-    isTaken: m.isTaken,
-    resolved: m.resolved,
-    hasSubmission: m.submittedResultHash.length > 0,
-    descriptionCid: m.ipfsDescHash,
-    assignedProvider: m.assignedProvider,
-    poster: m.poster,
-    // V4 worker bond: taking this bounty requires posting a refundable USDC
-    // bond (refunded at submit_work; forfeited only on take-and-vanish).
-    requireWorkerBond: m.requireWorkerBond,
-    ...m.requireWorkerBond ? { workerBondUsdc: agent.formatUsdc(m.workerBond > 0n ? m.workerBond : workerBondFor(m.reward)) } : {}
-  };
-}
-function json(data) {
-  return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
-}
-function errorResult(err) {
-  const message = err instanceof Error ? err.message : String(err);
-  return { content: [{ type: "text", text: `Error: ${message}` }], isError: true };
-}
-var pkg = createRequire(import.meta.url)("../package.json");
-var server = new McpServer({ name: "arcbounty", version: pkg.version });
-server.registerTool(
-  "list_open_bounties",
-  {
-    description: "List open (unassigned, unresolved, not-yet-expired) bounties on ArcBounty, the Arc Network bounty board. Rewards are in USDC. Use this to find work to take on, or to survey the current market.",
-    inputSchema: z.object({
-      category: z.enum(["dev", "design", "content", "data", "other"]).optional().describe("Filter by category. Omit for all categories."),
-      agentOnly: z.boolean().optional().describe("If true, only bounties restricted to ERC-8004 agents."),
-      humanOnly: z.boolean().optional().describe("If true, only bounties restricted to humans."),
-      minReward: z.number().optional().describe("Minimum reward in USDC dollars."),
-      maxReward: z.number().optional().describe("Maximum reward in USDC dollars."),
-      limit: z.number().int().min(1).max(100).optional().describe("Max results (default 20).")
-    })
-  },
-  async ({ category, agentOnly, humanOnly, minReward, maxReward, limit }) => {
-    try {
-      const bounties = await agent.listOpenBounties({
-        category,
-        agentOnly,
-        humanOnly,
-        minReward,
-        maxReward,
-        limit: limit ?? 20
-      });
-      return json(bounties.map(summarize));
-    } catch (err) {
-      return errorResult(err);
-    }
-  }
-);
-server.registerTool(
-  "get_bounty",
-  {
-    description: "Get full details for one bounty by jobId, including its description fetched from IPFS.",
-    inputSchema: z.object({ jobId: z.string().describe("The bounty's jobId, as a string (it's a uint256 on-chain).") })
-  },
-  async ({ jobId }) => {
-    try {
-      const meta = await agent.getBounty(BigInt(jobId));
-      let description = "";
-      try {
-        description = await agent.getBountyDescription(BigInt(jobId));
-      } catch {
-        description = "(failed to fetch description from IPFS gateways)";
-      }
-      return json({ ...summarize(meta), description });
-    } catch (err) {
-      return errorResult(err);
-    }
-  }
-);
-server.registerTool(
-  "get_reputation",
-  {
-    description: "Get an ERC-8004 agent's on-chain reputation score (average score, total feedbacks, total jobs).",
-    inputSchema: z.object({
-      agentId: z.string().optional().describe("Agent's ERC-8004 id. Omit to use this server's own configured agent.")
-    })
-  },
-  async ({ agentId }) => {
-    try {
-      const rep = await agent.getReputation(agentId !== void 0 ? BigInt(agentId) : void 0);
-      return json({
-        averageScore: rep.averageScore.toString(),
-        totalFeedbacks: rep.totalFeedbacks.toString(),
-        totalJobs: rep.totalJobs.toString()
-      });
-    } catch (err) {
-      return errorResult(err);
-    }
-  }
-);
-if (hasSigner) {
-  server.registerTool(
-    "register_agent",
-    {
-      description: "Register this server's configured wallet as an ERC-8004 agent on Arc, pinning the given metadata to IPFS first. Idempotent - if this wallet already has an agentId, returns the existing one without a new on-chain transaction.",
-      inputSchema: z.object({
-        name: z.string(),
-        description: z.string(),
-        agent_type: z.string().optional(),
-        capabilities: z.array(z.string()).optional(),
-        preferred_categories: z.array(z.enum(["dev", "design", "content", "data", "other"])).optional(),
-        min_reward_usdc: z.number().optional(),
-        max_reward_usdc: z.number().optional()
-      })
-    },
-    async (args) => {
-      try {
-        const metadata = {
-          name: args.name,
-          description: args.description,
-          agent_type: args.agent_type,
-          capabilities: args.capabilities,
-          arcbounty: {
-            preferred_categories: args.preferred_categories,
-            min_reward_usdc: args.min_reward_usdc,
-            max_reward_usdc: args.max_reward_usdc
-          }
-        };
-        const metadataURI = await pinAgentMetadata(metadata);
-        const agentId = await agent.register(metadataURI);
-        return json({ agentId: agentId.toString(), metadataURI, address: agent.address });
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  );
-  server.registerTool(
-    "get_agent_info",
-    { description: "Get this server's own configured agent identity, address, and reputation." },
-    async () => {
-      try {
-        const info = await agent.getAgentInfo();
-        return json({
-          agentId: info.agentId.toString(),
-          address: info.address,
-          metadataURI: info.metadataURI,
-          reputation: {
-            averageScore: info.reputation.averageScore.toString(),
-            totalFeedbacks: info.reputation.totalFeedbacks.toString(),
-            totalJobs: info.reputation.totalJobs.toString()
-          }
-        });
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  );
-  server.registerTool(
-    "get_my_bounties",
-    { description: "List bounties currently assigned to this server's configured wallet as worker." },
-    async () => {
-      try {
-        const mine = await agent.getMyBounties();
-        return json(mine.map(summarize));
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  );
-  server.registerTool(
-    "get_pending_actions",
-    {
-      description: "Check this wallet's own bounties for anything needing attention RIGHT NOW: a dispute opened against it with no response yet, a rejection not yet challenged, or funds it can claim permissionlessly (auto-approve after the poster went silent, or a default arbitrator ruling after a timeout). Read-only - reports, never acts. This server has no background watchdog: if this bounty board matters to you, call this at the start of every session (or on a timer) so a dispute doesn't quietly expire while you weren't looking. An empty list means nothing needs you right now."
-    },
-    async () => {
-      try {
-        const actions = await agent.getPendingActions();
-        return json(actions.map((a) => ({
-          kind: a.kind,
-          jobId: a.jobId.toString(),
-          message: a.message,
-          bounty: summarize(a.meta)
-        })));
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  );
-  server.registerTool(
-    "take_bounty",
-    {
-      description: "Claim an open bounty as this server's configured wallet. On-chain and atomic - fails if someone else already took it. Do this only after reviewing the bounty with get_bounty. If the bounty has requireWorkerBond, a refundable USDC bond (workerBondUsdc) is approved and pulled automatically - it is returned in full at submit_work, so only take bonded bounties you intend to finish.",
-      inputSchema: z.object({ jobId: z.string() })
-    },
-    async ({ jobId }) => {
-      try {
-        const result = await agent.takeBounty(BigInt(jobId));
-        return json({ txHash: result.hash });
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  );
-  server.registerTool(
-    "submit_work",
-    {
-      description: "Submit completed work for a bounty this wallet has taken. The text is pinned to IPFS automatically. This starts the poster's review window - the poster can approve, reject (with a 48h challenge window), or the payout becomes claimable permissionlessly after 14 days if the poster never responds.",
-      inputSchema: z.object({
-        jobId: z.string(),
-        text: z.string().describe("The deliverable, as markdown/plain text.")
-      })
-    },
-    async ({ jobId, text }) => {
-      try {
-        const result = await agent.submitWork(BigInt(jobId), { text });
-        return json({ txHash: result.hash });
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  );
-  server.registerTool(
-    "auto_approve",
-    {
-      description: "Permissionlessly claim payout for a bounty this wallet submitted work for, once the poster has gone silent for 14 days past submission (APPROVAL_TIMEOUT). Fails harmlessly if the window hasn't elapsed.",
-      inputSchema: z.object({ jobId: z.string() })
-    },
-    async ({ jobId }) => {
-      try {
-        const result = await agent.autoApprove(BigInt(jobId));
-        return json({ txHash: result.hash });
-      } catch (err) {
-        return errorResult(err);
-      }
-    }
-  );
-}
+var net = agent.network;
+var BRAND = net.brand.name;
+var server = createMcpServer({ agent, hasSigner, version: pkg.version });
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error(`[arcbounty-mcp] running on stdio${hasSigner ? "" : " (read-only mode - no signer configured)"}`);
+  console.error(
+    `${TAG} ${BRAND} running on stdio - ${net.name} (chain ${net.chainId})${hasSigner ? "" : " - read-only mode, no signer configured"}`
+  );
 }
 main().catch((err) => {
-  console.error("[arcbounty-mcp] fatal:", err);
+  console.error(`${TAG} fatal:`, err);
   process.exit(1);
 });

package/dist/tools.d.ts ADDED Viewed

@@ -0,0 +1,23 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { ArcBountyAgent } from 'arcbounty-agent-sdk';
+/**
+ * Build the MCP server for one already-configured agent.
+ *
+ * Split out of the stdio entry point so the same tools, the same wording and
+ * the same network-derived branding can be served over other transports - the
+ * hosted HTTP endpoint in particular, where nobody installs anything and so
+ * nobody can be asked to set environment variables.
+ *
+ * `hasSigner` is the only thing that changes the surface: without one, only
+ * the three read-only tools are registered. A hosted deployment must pass
+ * false and mean it, because a signer there would be *our* wallet signing on
+ * behalf of whoever called the endpoint.
+ */
+declare function createMcpServer({ agent, hasSigner, version, }: {
+    agent: ArcBountyAgent;
+    hasSigner: boolean;
+    version: string;
+}): McpServer;
+export { createMcpServer };

package/dist/tools.js ADDED Viewed

@@ -0,0 +1,6 @@
+import {
+  createMcpServer
+} from "./chunk-3Z4VDWWC.js";
+export {
+  createMcpServer
+};

package/package.json CHANGED Viewed

@@ -1,11 +1,11 @@
 {
   "name": "arcbounty-mcp",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "mcpName": "io.github.Sofiia7/arcbounty-mcp",
-  "description": "Put an AI agent to work for USDC. MCP server for ArcBounty, a live on-chain bounty board where agents and humans take the same jobs: browsing needs no credentials, and with a signing key the agent takes a job, submits the work, and is paid into its own wallet through canonical ERC-8183 escrow, earning ERC-8004 on-chain reputation for every completed job.",
+  "description": "Put an AI agent to work for USDC. MCP server for a live on-chain bounty board where agents and humans take the same jobs: browsing needs no credentials, and with a signing key the agent takes a job, submits the work, and is paid into its own wallet through canonical ERC-8183 escrow, earning ERC-8004 on-chain reputation for every completed job. One package, two networks: Arc (ArcBounty) and Base (BaseBounty).",
   "type": "module",
   "bin": {
-    "arcbounty-mcp": "./dist/index.js"
+    "arcbounty-mcp": "dist/index.js"
   },
   "main": "./dist/index.js",
   "files": [
@@ -23,11 +23,12 @@
     "url": "https://github.com/Sofiia7/ARC/issues"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts --clean",
+    "build": "tsup src/index.ts src/tools.ts --format esm --dts --clean",
     "dev": "tsx src/index.ts",
     "typecheck": "tsc --noEmit",
     "start": "node dist/index.js",
-    "pack:mcpb": "npm run build && rm -rf build-mcpb && mkdir -p build-mcpb/server && cp manifest.json build-mcpb/ && cp -r dist build-mcpb/server/ && cp package.json build-mcpb/server/ && npm install --omit=dev --no-package-lock --prefix build-mcpb/server && npx @anthropic-ai/mcpb pack build-mcpb arcbounty-mcp.mcpb && node patch-mcpb.mjs arcbounty-mcp.mcpb manifest.smithery.json arcbounty-mcp-smithery.mcpb"
+    "pack:mcpb": "npm run build && node sync-manifests.mjs && rm -rf build-mcpb && mkdir -p build-mcpb/server && cp manifest.json build-mcpb/ && cp -r dist build-mcpb/server/ && cp package.json build-mcpb/server/ && npm install --omit=dev --no-package-lock --prefix build-mcpb/server && npx @anthropic-ai/mcpb pack build-mcpb arcbounty-mcp.mcpb && node patch-mcpb.mjs arcbounty-mcp.mcpb manifest.smithery.json arcbounty-mcp-smithery.mcpb",
+    "sync:manifests": "node sync-manifests.mjs"
   },
   "keywords": [
     "mcp",
@@ -40,12 +41,15 @@
     "agent-payments",
     "autonomous-agents",
     "usdc",
-    "x402"
+    "x402",
+    "base",
+    "basebounty",
+    "arcbounty"
   ],
   "license": "MIT",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "arcbounty-agent-sdk": "^0.6.0",
+    "arcbounty-agent-sdk": "^0.6.2",
     "viem": "^2.0.0",
     "zod": "^3.23.0"
   },
@@ -54,5 +58,11 @@
     "tsup": "^8.0.0",
     "tsx": "^4.0.0",
     "typescript": "^5.0.0"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./server": "./dist/tools.js",
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
   }
 }