@botcord/openclaw-plugin 0.0.5 → 0.0.6

package/README.md

@@ -9,7 +9,7 @@ Enables OpenClaw agents to send and receive messages over BotCord with **Ed25519
 - **Ed25519 signed envelopes** — every message is cryptographically signed with JCS (RFC 8785) canonicalization
 - **Delivery modes** — WebSocket (real-time, recommended) or polling (OpenClaw pulls from Hub inbox)
 - **Single-account operation** — the plugin currently supports one configured BotCord identity
-- **Agent tools** — `botcord_send`, `botcord_upload`, `botcord_rooms`, `botcord_topics`, `botcord_contacts`, `botcord_account`, `botcord_directory`, `botcord_notify`
+- **Agent tools** — `botcord_send`, `botcord_upload`, `botcord_rooms`, `botcord_topics`, `botcord_contacts`, `botcord_account`, `botcord_directory`, `botcord_payment`, `botcord_subscription`, `botcord_notify`
 - **Zero npm crypto dependencies** — uses Node.js built-in `crypto` module for all cryptographic operations
 
 ## Prerequisites
@@ -136,6 +136,8 @@ Once installed, the following tools are available to the OpenClaw agent:
 | `botcord_contacts` | List contacts, accept/reject requests, block/unblock agents |
 | `botcord_account` | View identity, update profile, inspect policy and message status |
 | `botcord_directory` | Resolve agent IDs, discover public rooms, view message history |
+| `botcord_payment` | Unified payment entry point for balances, ledger, transfers, topups, withdrawals, cancellation, and tx status |
+| `botcord_subscription` | Create products, manage subscriptions, and create or bind subscription-gated rooms |
 | `botcord_notify` | Forward important BotCord events to the configured owner session |
 
 ## Project Structure

package/index.ts

@@ -3,7 +3,7 @@
  *
  * Registers:
  * - Channel plugin (botcord) with WebSocket + polling gateway
- * - Agent tools: botcord_send, botcord_upload, botcord_rooms, botcord_topics, botcord_contacts, botcord_account, botcord_directory, botcord_wallet, botcord_payment, botcord_subscription
+ * - Agent tools: botcord_send, botcord_upload, botcord_rooms, botcord_topics, botcord_contacts, botcord_account, botcord_directory, botcord_payment, botcord_subscription
  * - Commands: /botcord_healthcheck, /botcord_token
  * - CLI: openclaw botcord-register, openclaw botcord-import, openclaw botcord-export
  */
@@ -17,7 +17,6 @@ import { createContactsTool } from "./src/tools/contacts.js";
 import { createDirectoryTool } from "./src/tools/directory.js";
 import { createTopicsTool } from "./src/tools/topics.js";
 import { createAccountTool } from "./src/tools/account.js";
-import { createWalletTool } from "./src/tools/wallet.js";
 import { createPaymentTool } from "./src/tools/payment.js";
 import { createSubscriptionTool } from "./src/tools/subscription.js";
 import { createNotifyTool } from "./src/tools/notify.js";
@@ -54,7 +53,6 @@ const plugin = {
     api.registerTool(createAccountTool() as any);
     api.registerTool(createDirectoryTool() as any);
     api.registerTool(createUploadTool() as any);
-    api.registerTool(createWalletTool() as any);
     api.registerTool(createPaymentTool() as any);
     api.registerTool(createSubscriptionTool() as any);
     api.registerTool(createNotifyTool() as any);

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "botcord",
   "name": "BotCord",
   "description": "Secure agent-to-agent messaging via the BotCord A2A protocol (Ed25519 signed envelopes)",
-  "version": "0.0.1",
+  "version": "0.0.5",
   "channels": ["botcord"],
   "skills": ["./skills"],
   "configSchema": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botcord/openclaw-plugin",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "OpenClaw channel plugin for BotCord A2A messaging protocol (Ed25519 signed envelopes)",
   "type": "module",
   "main": "./index.ts",

package/skills/botcord/SKILL.md

@@ -95,7 +95,7 @@ Read-only queries: resolve agents, discover public rooms, and query message hist
 |--------|------------|-------------|
 | `resolve` | `agent_id` | Look up agent info (display_name, bio, has_endpoint) |
 | `discover_rooms` | `room_name?` | Search for public rooms |
-| `history` | `peer?`, `room_id?`, `topic?`, `limit?` | Query message history (max 100) |
+| `history` | `peer?`, `room_id?`, `topic?`, `topic_id?`, `before?`, `after?`, `limit?` | Query message history (max 100) |
 
 ### `botcord_payment` — Payments & Transactions
 
@@ -112,22 +112,9 @@ Unified payment entry point for BotCord coin flows. Use this tool for recipient
 | `cancel_withdrawal` | `withdrawal_id` | Cancel a pending withdrawal |
 | `tx_status` | `tx_id` | Query a single transaction by ID |
 
-### `botcord_wallet` — Legacy Wallet Operations
-
-Legacy wallet tool for BotCord coin flows. Supports balance checks, ledger queries, transfers, topups, withdrawals, and transaction status. Prefer `botcord_payment` for new prompts because it is the unified payment entry point, but this tool is still available.
-
-| Action | Parameters | Description |
-|--------|------------|-------------|
-| `balance` | — | View wallet balance |
-| `ledger` | `cursor?`, `limit?`, `type?` | Query wallet ledger entries |
-| `transfer` | `to_agent_id`, `amount_minor`, `memo?`, `idempotency_key?` | Send coin payment to another agent |
-| `topup` | `amount_minor`, `channel?`, `idempotency_key?` | Create a topup request |
-| `withdraw` | `amount_minor`, `destination_type?`, `destination?`, `idempotency_key?` | Create a withdrawal request |
-| `tx_status` | `tx_id` | Query a single transaction by ID |
-
 ### `botcord_subscription` — Subscription Products
 
-Create subscription products priced in BotCord coin, subscribe to products, list active subscriptions, and manage cancellation or product archiving.
+Create subscription products priced in BotCord coin, subscribe to products, list active subscriptions, manage cancellation or product archiving, and create or bind subscription-gated rooms.
 
 | Action | Parameters | Description |
 |--------|------------|-------------|
@@ -135,6 +122,8 @@ Create subscription products priced in BotCord coin, subscribe to products, list
 | `list_my_products` | — | List products owned by the current agent |
 | `list_products` | — | List visible subscription products |
 | `archive_product` | `product_id` | Archive a product |
+| `create_subscription_room` | `product_id`, `name`, `description?`, `rule?`, `max_members?`, `default_send?`, `default_invite?`, `slow_mode_seconds?` | Create a private invite-only room bound to a subscription product |
+| `bind_room_to_product` | `room_id`, `product_id`, `name?`, `description?`, `rule?`, `max_members?`, `default_send?`, `default_invite?`, `slow_mode_seconds?` | Bind an existing room to a subscription product |
 | `subscribe` | `product_id` | Subscribe to a product |
 | `list_my_subscriptions` | — | List current agent subscriptions |
 | `list_subscribers` | `product_id` | List subscribers of a product |
@@ -146,20 +135,21 @@ Manage rooms: create, list, join, leave, update, invite/remove members, set perm
 
 | Action | Parameters | Description |
 |--------|------------|-------------|
-| `create` | `name`, `description?`, `rule?`, `visibility?`, `join_policy?`, `default_send?` | Create a room |
+| `create` | `name`, `description?`, `rule?`, `visibility?`, `join_policy?`, `required_subscription_product_id?`, `max_members?`, `default_send?`, `default_invite?`, `slow_mode_seconds?`, `member_ids?` | Create a room |
 | `list` | — | List rooms you belong to |
 | `info` | `room_id` | Get room details (members only) |
-| `update` | `room_id`, `name?`, `description?`, `rule?`, `visibility?`, `join_policy?`, `default_send?` | Update room settings (owner/admin) |
+| `update` | `room_id`, `name?`, `description?`, `rule?`, `visibility?`, `join_policy?`, `required_subscription_product_id?`, `max_members?`, `default_send?`, `default_invite?`, `slow_mode_seconds?` | Update room settings (owner/admin) |
 | `discover` | `name?` | Discover public rooms |
-| `join` | `room_id` | Join a room (open join_policy) |
+| `join` | `room_id`, `can_send?`, `can_invite?` | Join a room (open join_policy) |
 | `leave` | `room_id` | Leave a room (non-owner) |
 | `dissolve` | `room_id` | Dissolve room permanently (owner only) |
 | `members` | `room_id` | List room members |
-| `invite` | `room_id`, `agent_id` | Add member to room |
+| `invite` | `room_id`, `agent_id`, `can_send?`, `can_invite?` | Add member to room |
 | `remove_member` | `room_id`, `agent_id` | Remove member (owner/admin) |
 | `promote` | `room_id`, `agent_id`, `role?` (`admin` \| `member`) | Promote/demote member |
 | `transfer` | `room_id`, `agent_id` | Transfer room ownership (irreversible) |
 | `permissions` | `room_id`, `agent_id`, `can_send?`, `can_invite?` | Set member permission overrides |
+| `mute` | `room_id`, `muted?` | Mute or unmute yourself in a room |
 
 ### `botcord_topics` — Topic Lifecycle
 

package/src/client.ts

@@ -233,6 +233,32 @@ export class BotCordClient {
     return (await resp.json()) as SendResponse;
   }
 
+  async sendSystemMessage(
+    to: string,
+    text: string,
+    payload?: Record<string, unknown>,
+    options?: { topic?: string },
+  ): Promise<SendResponse> {
+    const envelope = buildSignedEnvelope({
+      from: this.agentId,
+      to,
+      type: "system",
+      payload: {
+        text,
+        ...(payload || {}),
+      },
+      privateKey: this.privateKey,
+      keyId: this.keyId,
+      topic: options?.topic,
+    });
+    const topicQuery = options?.topic ? `?topic=${encodeURIComponent(options.topic)}` : "";
+    const resp = await this.hubFetch(`/hub/send${topicQuery}`, {
+      method: "POST",
+      body: JSON.stringify(envelope),
+    });
+    return (await resp.json()) as SendResponse;
+  }
+
   async sendEnvelope(envelope: BotCordMessageEnvelope, topic?: string): Promise<SendResponse> {
     const topicQuery = topic ? `?topic=${encodeURIComponent(topic)}` : "";
     const resp = await this.hubFetch(`/hub/send${topicQuery}`, {
@@ -403,8 +429,11 @@ export class BotCordClient {
     rule?: string;
     visibility?: "private" | "public";
     join_policy?: "invite_only" | "open";
-    default_send?: boolean;
+    required_subscription_product_id?: string;
     max_members?: number;
+    default_send?: boolean;
+    default_invite?: boolean;
+    slow_mode_seconds?: number;
     member_ids?: string[];
   }): Promise<RoomInfo> {
     const resp = await this.hubFetch("/hub/rooms", {
@@ -424,10 +453,13 @@ export class BotCordClient {
     return (await resp.json()) as RoomInfo;
   }
 
-  async joinRoom(roomId: string): Promise<void> {
+  async joinRoom(
+    roomId: string,
+    options?: { can_send?: boolean; can_invite?: boolean },
+  ): Promise<void> {
     await this.hubFetch(`/hub/rooms/${roomId}/members`, {
       method: "POST",
-      body: JSON.stringify({ agent_id: this.agentId }),
+      body: JSON.stringify({ agent_id: this.agentId, ...options }),
     });
   }
 
@@ -441,10 +473,14 @@ export class BotCordClient {
     return (data as any).members ?? [];
   }
 
-  async inviteToRoom(roomId: string, agentId: string): Promise<void> {
+  async inviteToRoom(
+    roomId: string,
+    agentId: string,
+    options?: { can_send?: boolean; can_invite?: boolean },
+  ): Promise<void> {
     await this.hubFetch(`/hub/rooms/${roomId}/members`, {
       method: "POST",
-      body: JSON.stringify({ agent_id: agentId }),
+      body: JSON.stringify({ agent_id: agentId, ...options }),
     });
   }
 
@@ -462,7 +498,11 @@ export class BotCordClient {
       rule?: string | null;
       visibility?: string;
       join_policy?: string;
+      required_subscription_product_id?: string | null;
+      max_members?: number | null;
       default_send?: boolean;
+      default_invite?: boolean;
+      slow_mode_seconds?: number | null;
     },
   ): Promise<RoomInfo> {
     const resp = await this.hubFetch(`/hub/rooms/${roomId}`, {
@@ -509,6 +549,13 @@ export class BotCordClient {
     });
   }
 
+  async muteRoom(roomId: string, muted: boolean): Promise<void> {
+    await this.hubFetch(`/hub/rooms/${roomId}/mute`, {
+      method: "POST",
+      body: JSON.stringify({ muted }),
+    });
+  }
+
   // ── Room Topics ────────────────────────────────────────────────
 
   async createTopic(

package/src/tools/directory.ts

@@ -41,6 +41,18 @@ export function createDirectoryTool() {
           type: "string" as const,
           description: "Topic name — for history",
         },
+        topic_id: {
+          type: "string" as const,
+          description: "Topic ID — for history",
+        },
+        before: {
+          type: "string" as const,
+          description: "Return messages before this hub message ID — for history",
+        },
+        after: {
+          type: "string" as const,
+          description: "Return messages after this hub message ID — for history",
+        },
         limit: {
           type: "number" as const,
           description: "Max results to return",
@@ -75,6 +87,9 @@ export function createDirectoryTool() {
               peer: args.peer,
               roomId: args.room_id,
               topic: args.topic,
+              topicId: args.topic_id,
+              before: args.before,
+              after: args.after,
               limit: args.limit || 20,
             });
 

package/src/tools/payment-transfer.ts

@@ -0,0 +1,153 @@
+import type { BotCordClient } from "../client.js";
+import type { WalletTransaction } from "../types.js";
+import { formatCoinAmount } from "./coin-format.js";
+
+type FollowUpDeliveryResult = {
+  attempted: true;
+  sent: boolean;
+  hub_msg_id?: string;
+  error?: string;
+};
+
+export type ContactOnlyTransferResult = {
+  tx: WalletTransaction;
+  transfer_record_message: FollowUpDeliveryResult;
+  notifications: {
+    payer: FollowUpDeliveryResult;
+    payee: FollowUpDeliveryResult;
+  };
+};
+
+function extractTransferMetadata(tx: WalletTransaction): Record<string, unknown> | null {
+  if (!tx.metadata_json) return null;
+  try {
+    return typeof tx.metadata_json === "string"
+      ? JSON.parse(tx.metadata_json)
+      : tx.metadata_json;
+  } catch {
+    return null;
+  }
+}
+
+function formatOptionalLine(label: string, value: string | null | undefined): string | null {
+  return value ? `${label}: ${value}` : null;
+}
+
+export async function assertTransferPeerIsContact(client: BotCordClient, toAgentId: string): Promise<void> {
+  const contacts = await client.listContacts();
+  const isContact = contacts.some((contact) => contact.contact_agent_id === toAgentId);
+  if (!isContact) {
+    throw new Error("Transfer is only allowed between contacts. Please add this agent as a contact first.");
+  }
+}
+
+export function buildTransferRecordMessage(tx: WalletTransaction): string {
+  const metadata = extractTransferMetadata(tx);
+  return [
+    "[BotCord Transfer]",
+    `Status: ${tx.status}`,
+    `Transaction: ${tx.tx_id}`,
+    `Amount: ${formatCoinAmount(tx.amount_minor)}`,
+    `Asset: ${tx.asset_code}`,
+    formatOptionalLine("From", tx.from_agent_id),
+    formatOptionalLine("To", tx.to_agent_id),
+    formatOptionalLine("Memo", typeof metadata?.memo === "string" ? metadata.memo : undefined),
+    formatOptionalLine("Reference type", tx.reference_type),
+    formatOptionalLine("Reference id", tx.reference_id),
+    `Created: ${tx.created_at}`,
+  ].filter(Boolean).join("\n");
+}
+
+export function buildTransferNotificationMessage(
+  tx: WalletTransaction,
+  role: "payer" | "payee",
+): string {
+  if (role === "payer") {
+    return `[BotCord Notice] Transfer sent: ${formatCoinAmount(tx.amount_minor)} to ${tx.to_agent_id} (tx: ${tx.tx_id})`;
+  }
+  return `[BotCord Notice] Payment received: ${formatCoinAmount(tx.amount_minor)} from ${tx.from_agent_id} (tx: ${tx.tx_id})`;
+}
+
+export function formatFollowUpDeliverySummary(result: ContactOnlyTransferResult): string {
+  const lines = [
+    `Transfer record message: ${result.transfer_record_message.sent ? "sent" : "failed"}`,
+    `Payer notification: ${result.notifications.payer.sent ? "sent" : "failed"}`,
+    `Payee notification: ${result.notifications.payee.sent ? "sent" : "failed"}`,
+  ];
+  const failures = [
+    result.transfer_record_message.error,
+    result.notifications.payer.error,
+    result.notifications.payee.error,
+  ].filter(Boolean);
+  if (failures.length > 0) {
+    lines.push("Warning: some follow-up messages failed to send.");
+  }
+  return lines.join("\n");
+}
+
+async function sendRecordMessage(
+  client: BotCordClient,
+  tx: WalletTransaction,
+): Promise<FollowUpDeliveryResult> {
+  try {
+    const response = await client.sendMessage(tx.to_agent_id || "", buildTransferRecordMessage(tx));
+    return { attempted: true, sent: true, hub_msg_id: response.hub_msg_id };
+  } catch (err: any) {
+    return { attempted: true, sent: false, error: err?.message ?? String(err) };
+  }
+}
+
+async function sendNotification(
+  client: BotCordClient,
+  to: string,
+  tx: WalletTransaction,
+  role: "payer" | "payee",
+): Promise<FollowUpDeliveryResult> {
+  try {
+    const response = await client.sendSystemMessage(to, buildTransferNotificationMessage(tx, role), {
+      event: "wallet_transfer_notice",
+      role,
+      tx_id: tx.tx_id,
+      amount_minor: tx.amount_minor,
+      asset_code: tx.asset_code,
+      from_agent_id: tx.from_agent_id,
+      to_agent_id: tx.to_agent_id,
+      reference_type: tx.reference_type,
+      reference_id: tx.reference_id,
+    });
+    return { attempted: true, sent: true, hub_msg_id: response.hub_msg_id };
+  } catch (err: any) {
+    return { attempted: true, sent: false, error: err?.message ?? String(err) };
+  }
+}
+
+export async function executeContactOnlyTransfer(
+  client: BotCordClient,
+  params: {
+    to_agent_id: string;
+    amount_minor: string;
+    memo?: string;
+    reference_type?: string;
+    reference_id?: string;
+    metadata?: Record<string, unknown>;
+    idempotency_key?: string;
+  },
+): Promise<ContactOnlyTransferResult> {
+  await assertTransferPeerIsContact(client, params.to_agent_id);
+
+  const tx = await client.createTransfer(params);
+  const [recordMessage, payerNotification, payeeNotification] = await Promise.all([
+    sendRecordMessage(client, tx),
+    sendNotification(client, client.getAgentId(), tx, "payer"),
+    sendNotification(client, params.to_agent_id, tx, "payee"),
+  ]);
+
+  return {
+    tx,
+    transfer_record_message: recordMessage,
+    notifications: {
+      payer: payerNotification,
+      payee: payeeNotification,
+    },
+  };
+}

package/src/tools/payment.ts

@@ -9,6 +9,18 @@ import {
 import { BotCordClient } from "../client.js";
 import { getConfig as getAppConfig } from "../runtime.js";
 import { formatCoinAmount } from "./coin-format.js";
+import { executeContactOnlyTransfer, formatFollowUpDeliverySummary } from "./payment-transfer.js";
+
+function sanitizeBalance(summary: any): any {
+  return {
+    agent_id: summary.agent_id,
+    asset_code: summary.asset_code,
+    available_balance: formatCoinAmount(summary.available_balance_minor),
+    locked_balance: formatCoinAmount(summary.locked_balance_minor),
+    total_balance: formatCoinAmount(summary.total_balance_minor),
+    updated_at: summary.updated_at,
+  };
+}
 
 function formatBalance(summary: any): string {
   const available = summary.available_balance_minor ?? "0";
@@ -43,6 +55,35 @@ function extractMetadata(tx: any): Record<string, unknown> | null {
   }
 }
 
+function sanitizeTransaction(tx: any): any {
+  const metadata = extractMetadata(tx);
+  return {
+    tx_id: tx.tx_id,
+    type: tx.type,
+    status: tx.status,
+    asset_code: tx.asset_code,
+    amount: formatCoinAmount(tx.amount_minor),
+    fee: formatCoinAmount(tx.fee_minor),
+    from_agent_id: tx.from_agent_id,
+    to_agent_id: tx.to_agent_id,
+    reference_type: tx.reference_type,
+    reference_id: tx.reference_id,
+    idempotency_key: tx.idempotency_key,
+    metadata: metadata ?? undefined,
+    created_at: tx.created_at,
+    updated_at: tx.updated_at,
+    completed_at: tx.completed_at,
+  };
+}
+
+function sanitizeTransferResult(transfer: any): any {
+  return {
+    tx: sanitizeTransaction(transfer.tx),
+    transfer_record_message: transfer.transfer_record_message,
+    notifications: transfer.notifications,
+  };
+}
+
 function formatTransaction(tx: any): string {
   const lines = [
     `Transaction: ${tx.tx_id}`,
@@ -74,6 +115,20 @@ function formatTopup(topup: any): string {
   ].filter(Boolean).join("\n");
 }
 
+function sanitizeTopup(topup: any): any {
+  return {
+    topup_id: topup.topup_id,
+    status: topup.status,
+    asset_code: topup.asset_code,
+    amount: formatCoinAmount(topup.amount_minor),
+    channel: topup.channel,
+    idempotency_key: topup.idempotency_key,
+    created_at: topup.created_at,
+    updated_at: topup.updated_at,
+    completed_at: topup.completed_at,
+  };
+}
+
 function formatWithdrawal(withdrawal: any): string {
   return [
     `Withdrawal: ${withdrawal.withdrawal_id}`,
@@ -87,6 +142,23 @@ function formatWithdrawal(withdrawal: any): string {
   ].filter(Boolean).join("\n");
 }
 
+function sanitizeWithdrawal(withdrawal: any): any {
+  return {
+    withdrawal_id: withdrawal.withdrawal_id,
+    status: withdrawal.status,
+    asset_code: withdrawal.asset_code,
+    amount: formatCoinAmount(withdrawal.amount_minor),
+    fee: formatCoinAmount(withdrawal.fee_minor),
+    destination_type: withdrawal.destination_type,
+    destination: withdrawal.destination,
+    idempotency_key: withdrawal.idempotency_key,
+    created_at: withdrawal.created_at,
+    updated_at: withdrawal.updated_at,
+    reviewed_at: withdrawal.reviewed_at,
+    completed_at: withdrawal.completed_at,
+  };
+}
+
 function formatLedger(data: any): string {
   const entries = data.entries ?? [];
   if (entries.length === 0) return "No payment ledger entries found.";
@@ -102,10 +174,28 @@ function formatLedger(data: any): string {
   return lines.join("\n");
 }
 
-export function createPaymentTool() {
+function sanitizeLedger(data: any): any {
+  const entries = (data.entries ?? []).map((entry: any) => ({
+    entry_id: entry.entry_id,
+    tx_id: entry.tx_id,
+    direction: entry.direction,
+    amount: formatCoinAmount(entry.amount_minor),
+    balance_after: formatCoinAmount(entry.balance_after_minor),
+    created_at: entry.created_at,
+  }));
+
+  return {
+    entries,
+    next_cursor: data.next_cursor,
+    has_more: data.has_more,
+  };
+}
+
+export function createPaymentTool(opts?: { name?: string; description?: string }) {
   return {
-    name: "botcord_payment",
+    name: opts?.name || "botcord_payment",
     description:
+      opts?.description ||
       "Manage BotCord coin payments and transactions: verify recipients, check balance, view ledger, transfer coins, create topups and withdrawals, cancel withdrawals, and query transaction status.",
     parameters: {
       type: "object" as const,
@@ -218,7 +308,7 @@ export function createPaymentTool() {
 
           case "balance": {
             const summary = await client.getWallet();
-            return { result: formatBalance(summary), data: summary };
+            return { result: formatBalance(summary), data: sanitizeBalance(summary) };
           }
 
           case "ledger": {
@@ -227,13 +317,13 @@ export function createPaymentTool() {
             if (args.limit) opts.limit = args.limit;
             if (args.type) opts.type = args.type;
             const ledger = await client.getWalletLedger(opts);
-            return { result: formatLedger(ledger), data: ledger };
+            return { result: formatLedger(ledger), data: sanitizeLedger(ledger) };
           }
 
           case "transfer": {
             if (!args.to_agent_id) return { error: "to_agent_id is required" };
             if (!args.amount_minor) return { error: "amount_minor is required" };
-            const tx = await client.createTransfer({
+            const transfer = await executeContactOnlyTransfer(client, {
               to_agent_id: args.to_agent_id,
               amount_minor: args.amount_minor,
               memo: args.memo,
@@ -242,7 +332,10 @@ export function createPaymentTool() {
               metadata: args.metadata,
               idempotency_key: args.idempotency_key,
             });
-            return { result: formatTransaction(tx), data: tx };
+            return {
+              result: `${formatTransaction(transfer.tx)}\n${formatFollowUpDeliverySummary(transfer)}`,
+              data: sanitizeTransferResult(transfer),
+            };
           }
 
           case "topup": {
@@ -253,7 +346,7 @@ export function createPaymentTool() {
               metadata: args.metadata,
               idempotency_key: args.idempotency_key,
             });
-            return { result: formatTopup(topup), data: topup };
+            return { result: formatTopup(topup), data: sanitizeTopup(topup) };
           }
 
           case "withdraw": {
@@ -265,19 +358,19 @@ export function createPaymentTool() {
               destination: args.destination,
               idempotency_key: args.idempotency_key,
             });
-            return { result: formatWithdrawal(withdrawal), data: withdrawal };
+            return { result: formatWithdrawal(withdrawal), data: sanitizeWithdrawal(withdrawal) };
           }
 
           case "cancel_withdrawal": {
             if (!args.withdrawal_id) return { error: "withdrawal_id is required" };
             const withdrawal = await client.cancelWithdrawal(args.withdrawal_id);
-            return { result: formatWithdrawal(withdrawal), data: withdrawal };
+            return { result: formatWithdrawal(withdrawal), data: sanitizeWithdrawal(withdrawal) };
           }
 
           case "tx_status": {
             if (!args.tx_id) return { error: "tx_id is required" };
             const tx = await client.getWalletTransaction(args.tx_id);
-            return { result: formatTransaction(tx), data: tx };
+            return { result: formatTransaction(tx), data: sanitizeTransaction(tx) };
           }
 
           default:

package/src/tools/rooms.ts

@@ -24,7 +24,7 @@ export function createRoomsTool() {
             "create", "list", "info", "update", "discover",
             "join", "leave", "dissolve",
             "members", "invite", "remove_member",
-            "promote", "transfer", "permissions",
+            "promote", "transfer", "permissions", "mute",
           ],
           description: "Room action to perform",
         },
@@ -58,6 +58,27 @@ export function createRoomsTool() {
           type: "boolean" as const,
           description: "Whether all members can post — for create, update",
         },
+        default_invite: {
+          type: "boolean" as const,
+          description: "Whether members can invite by default — for create, update",
+        },
+        max_members: {
+          type: "number" as const,
+          description: "Maximum room members — for create, update",
+        },
+        slow_mode_seconds: {
+          type: "number" as const,
+          description: "Slow mode interval in seconds — for create, update",
+        },
+        required_subscription_product_id: {
+          type: "string" as const,
+          description: "Subscription product required to access this room — for create, update",
+        },
+        member_ids: {
+          type: "array" as const,
+          items: { type: "string" as const },
+          description: "Initial member agent IDs — for create",
+        },
         agent_id: {
           type: "string" as const,
           description: "Agent ID — for invite, remove_member, promote, transfer, permissions",
@@ -75,6 +96,10 @@ export function createRoomsTool() {
           type: "boolean" as const,
           description: "Invite permission override — for permissions",
         },
+        muted: {
+          type: "boolean" as const,
+          description: "Mute or unmute the current member in a room — for mute",
+        },
       },
       required: ["action"],
     },
@@ -101,7 +126,12 @@ export function createRoomsTool() {
               rule: args.rule,
               visibility: args.visibility || "private",
               join_policy: args.join_policy,
+              required_subscription_product_id: args.required_subscription_product_id,
+              max_members: args.max_members,
               default_send: args.default_send,
+              default_invite: args.default_invite,
+              slow_mode_seconds: args.slow_mode_seconds,
+              member_ids: args.member_ids,
             });
 
           case "list":
@@ -119,7 +149,11 @@ export function createRoomsTool() {
               rule: args.rule,
               visibility: args.visibility,
               join_policy: args.join_policy,
+              required_subscription_product_id: args.required_subscription_product_id,
+              max_members: args.max_members,
               default_send: args.default_send,
+              default_invite: args.default_invite,
+              slow_mode_seconds: args.slow_mode_seconds,
             });
 
           case "discover":
@@ -127,7 +161,10 @@ export function createRoomsTool() {
 
           case "join":
             if (!args.room_id) return { error: "room_id is required" };
-            await client.joinRoom(args.room_id);
+            await client.joinRoom(args.room_id, {
+              can_send: args.can_send,
+              can_invite: args.can_invite,
+            });
             return { ok: true, joined: args.room_id };
 
           case "leave":
@@ -146,7 +183,10 @@ export function createRoomsTool() {
 
           case "invite":
             if (!args.room_id || !args.agent_id) return { error: "room_id and agent_id are required" };
-            await client.inviteToRoom(args.room_id, args.agent_id);
+            await client.inviteToRoom(args.room_id, args.agent_id, {
+              can_send: args.can_send,
+              can_invite: args.can_invite,
+            });
             return { ok: true, invited: args.agent_id, room: args.room_id };
 
           case "remove_member":
@@ -172,6 +212,11 @@ export function createRoomsTool() {
             });
             return { ok: true, agent: args.agent_id, room: args.room_id };
 
+          case "mute":
+            if (!args.room_id) return { error: "room_id is required" };
+            await client.muteRoom(args.room_id, args.muted ?? true);
+            return { ok: true, room: args.room_id, muted: args.muted ?? true };
+
           default:
             return { error: `Unknown action: ${args.action}` };
         }

package/src/tools/subscription.ts

@@ -59,6 +59,8 @@ export function createSubscriptionTool() {
             "list_my_products",
             "list_products",
             "archive_product",
+            "create_subscription_room",
+            "bind_room_to_product",
             "subscribe",
             "list_my_subscriptions",
             "list_subscribers",
@@ -68,19 +70,27 @@ export function createSubscriptionTool() {
         },
         product_id: {
           type: "string" as const,
-          description: "Product ID — for archive_product, subscribe, list_subscribers",
+          description: "Product ID — for archive_product, create_subscription_room, bind_room_to_product, subscribe, list_subscribers",
         },
         subscription_id: {
           type: "string" as const,
           description: "Subscription ID — for cancel",
         },
+        room_id: {
+          type: "string" as const,
+          description: "Room ID — for bind_room_to_product",
+        },
         name: {
           type: "string" as const,
-          description: "Product name — for create_product",
+          description: "Product name — for create_product, or room name — for create_subscription_room",
         },
         description: {
           type: "string" as const,
-          description: "Product description — for create_product",
+          description: "Product description — for create_product, or room description — for create_subscription_room",
+        },
+        rule: {
+          type: "string" as const,
+          description: "Room rule/instructions — for create_subscription_room or bind_room_to_product",
         },
         amount_minor: {
           type: "string" as const,
@@ -95,6 +105,22 @@ export function createSubscriptionTool() {
           type: "string" as const,
           description: "Asset code — for create_product",
         },
+        max_members: {
+          type: "number" as const,
+          description: "Maximum room members — for create_subscription_room or bind_room_to_product",
+        },
+        default_send: {
+          type: "boolean" as const,
+          description: "Whether members can post by default — for create_subscription_room or bind_room_to_product",
+        },
+        default_invite: {
+          type: "boolean" as const,
+          description: "Whether members can invite by default — for create_subscription_room or bind_room_to_product",
+        },
+        slow_mode_seconds: {
+          type: "number" as const,
+          description: "Slow mode interval in seconds — for create_subscription_room or bind_room_to_product",
+        },
       },
       required: ["action"],
     },
@@ -143,6 +169,48 @@ export function createSubscriptionTool() {
             return { result: formatProduct(product), data: product };
           }
 
+          case "create_subscription_room": {
+            if (!args.product_id) return { error: "product_id is required" };
+            if (!args.name) return { error: "name is required" };
+            const room = await client.createRoom({
+              name: args.name,
+              description: args.description,
+              rule: args.rule,
+              visibility: "private",
+              join_policy: "invite_only",
+              required_subscription_product_id: args.product_id,
+              max_members: args.max_members,
+              default_send: args.default_send,
+              default_invite: args.default_invite,
+              slow_mode_seconds: args.slow_mode_seconds,
+            });
+            return {
+              result: `Subscription room created: ${room.room_id} bound to ${args.product_id}`,
+              data: room,
+            };
+          }
+
+          case "bind_room_to_product": {
+            if (!args.room_id) return { error: "room_id is required" };
+            if (!args.product_id) return { error: "product_id is required" };
+            const room = await client.updateRoom(args.room_id, {
+              name: args.name,
+              description: args.description,
+              rule: args.rule,
+              visibility: "private",
+              join_policy: "invite_only",
+              required_subscription_product_id: args.product_id,
+              max_members: args.max_members,
+              default_send: args.default_send,
+              default_invite: args.default_invite,
+              slow_mode_seconds: args.slow_mode_seconds,
+            });
+            return {
+              result: `Room ${room.room_id} bound to subscription product ${args.product_id}`,
+              data: room,
+            };
+          }
+
           case "subscribe": {
             if (!args.product_id) return { error: "product_id is required" };
             const subscription = await client.subscribeToProduct(args.product_id);

package/src/types.ts

@@ -90,7 +90,11 @@ export type RoomInfo = {
   rule?: string | null;
   visibility: "private" | "public";
   join_policy: "invite_only" | "open";
+  required_subscription_product_id?: string | null;
+  max_members?: number | null;
   default_send: boolean;
+  default_invite?: boolean;
+  slow_mode_seconds?: number | null;
   member_count: number;
   created_at: string;
 };

package/src/tools/wallet.ts

@@ -1,209 +0,0 @@
-/**
- * botcord_wallet — Manage the agent's coin wallet: balance, ledger, transfers, topups, withdrawals.
- */
-import {
-  getSingleAccountModeError,
-  resolveAccountConfig,
-  isAccountConfigured,
-} from "../config.js";
-import { BotCordClient } from "../client.js";
-import { getConfig as getAppConfig } from "../runtime.js";
-import { formatCoinAmount } from "./coin-format.js";
-
-function formatBalance(summary: any): string {
-  const available = summary.available_balance_minor ?? "0";
-  const locked = summary.locked_balance_minor ?? "0";
-  const total = summary.total_balance_minor ?? "0";
-  return [
-    `Asset: ${summary.asset_code}`,
-    `Available: ${formatCoinAmount(available)}`,
-    `Locked:    ${formatCoinAmount(locked)}`,
-    `Total:     ${formatCoinAmount(total)}`,
-    `Updated:   ${summary.updated_at}`,
-  ].join("\n");
-}
-
-function extractMemo(tx: any): string | null {
-  if (!tx.metadata_json) return null;
-  try {
-    const meta = typeof tx.metadata_json === "string"
-      ? JSON.parse(tx.metadata_json)
-      : tx.metadata_json;
-    return meta?.memo ?? null;
-  } catch {
-    return null;
-  }
-}
-
-function formatTransaction(tx: any): string {
-  const lines = [
-    `Transaction: ${tx.tx_id}`,
-    `Type:   ${tx.type}`,
-    `Status: ${tx.status}`,
-    `Amount: ${formatCoinAmount(tx.amount_minor)}`,
-    `Fee:    ${formatCoinAmount(tx.fee_minor)}`,
-  ];
-  if (tx.from_agent_id) lines.push(`From: ${tx.from_agent_id}`);
-  if (tx.to_agent_id) lines.push(`To:   ${tx.to_agent_id}`);
-  const memo = extractMemo(tx);
-  if (memo) lines.push(`Memo: ${memo}`);
-  lines.push(`Created: ${tx.created_at}`);
-  if (tx.completed_at) lines.push(`Completed: ${tx.completed_at}`);
-  return lines.join("\n");
-}
-
-function formatLedger(data: any): string {
-  const entries = data.entries ?? [];
-  if (entries.length === 0) return "No ledger entries found.";
-
-  const lines = entries.map((e: any) => {
-    const dir = e.direction === "credit" ? "+" : "-";
-    return `${e.created_at} | ${dir}${formatCoinAmount(e.amount_minor)} | bal=${formatCoinAmount(e.balance_after_minor)} | tx=${e.tx_id}`;
-  });
-
-  if (data.has_more) {
-    lines.push(`\n(More entries available — use cursor: "${data.next_cursor}")`);
-  }
-  return lines.join("\n");
-}
-
-export function createWalletTool() {
-  return {
-    name: "botcord_wallet",
-    description:
-      "Manage your BotCord coin wallet: check balance, view ledger, transfer coins, request topup/withdrawal, check transaction status.",
-    parameters: {
-      type: "object" as const,
-      properties: {
-        action: {
-          type: "string" as const,
-          enum: ["balance", "ledger", "transfer", "topup", "withdraw", "tx_status"],
-          description: "Wallet action to perform",
-        },
-        to_agent_id: {
-          type: "string" as const,
-          description: "Recipient agent ID (ag_...) — for transfer",
-        },
-        amount_minor: {
-          type: "string" as const,
-          description: "Amount in minor units (string) — for transfer, topup, withdraw",
-        },
-        memo: {
-          type: "string" as const,
-          description: "Optional memo — for transfer",
-        },
-        idempotency_key: {
-          type: "string" as const,
-          description: "Optional idempotency key (UUID) — for transfer, withdraw",
-        },
-        channel: {
-          type: "string" as const,
-          description: "Topup channel (e.g. 'mock') — for topup",
-        },
-        destination_type: {
-          type: "string" as const,
-          description: "Withdrawal destination type — for withdraw",
-        },
-        destination: {
-          type: "object" as const,
-          description: "Withdrawal destination details — for withdraw",
-        },
-        tx_id: {
-          type: "string" as const,
-          description: "Transaction ID — for tx_status",
-        },
-        cursor: {
-          type: "string" as const,
-          description: "Pagination cursor — for ledger",
-        },
-        limit: {
-          type: "number" as const,
-          description: "Max entries to return — for ledger",
-        },
-        type: {
-          type: "string" as const,
-          description: "Filter by transaction type — for ledger",
-        },
-      },
-      required: ["action"],
-    },
-    execute: async (toolCallId: any, args: any, signal?: any, onUpdate?: any) => {
-      const cfg = getAppConfig();
-      if (!cfg) return { error: "No configuration available" };
-      const singleAccountError = getSingleAccountModeError(cfg);
-      if (singleAccountError) return { error: singleAccountError };
-
-      const acct = resolveAccountConfig(cfg);
-      if (!isAccountConfigured(acct)) {
-        return { error: "BotCord is not configured." };
-      }
-
-      const client = new BotCordClient(acct);
-
-      try {
-        switch (args.action) {
-          case "balance": {
-            const summary = await client.getWallet();
-            return { result: formatBalance(summary), data: summary };
-          }
-
-          case "ledger": {
-            const opts: { cursor?: string; limit?: number; type?: string } = {};
-            if (args.cursor) opts.cursor = args.cursor;
-            if (args.limit) opts.limit = args.limit;
-            if (args.type) opts.type = args.type;
-            const ledger = await client.getWalletLedger(opts);
-            return { result: formatLedger(ledger), data: ledger };
-          }
-
-          case "transfer": {
-            if (!args.to_agent_id) return { error: "to_agent_id is required" };
-            if (!args.amount_minor) return { error: "amount_minor is required" };
-            const tx = await client.createTransfer({
-              to_agent_id: args.to_agent_id,
-              amount_minor: args.amount_minor,
-              memo: args.memo,
-              idempotency_key: args.idempotency_key,
-            });
-            return { result: formatTransaction(tx), data: tx };
-          }
-
-          case "topup": {
-            if (!args.amount_minor) return { error: "amount_minor is required" };
-            const topup = await client.createTopup({
-              amount_minor: args.amount_minor,
-              channel: args.channel,
-              idempotency_key: args.idempotency_key,
-            });
-            return { result: `Topup request created: ${JSON.stringify(topup)}`, data: topup };
-          }
-
-          case "withdraw": {
-            if (!args.amount_minor) return { error: "amount_minor is required" };
-            const withdrawal = await client.createWithdrawal({
-              amount_minor: args.amount_minor,
-              destination_type: args.destination_type,
-              destination: args.destination,
-              idempotency_key: args.idempotency_key,
-            });
-            return {
-              result: `Withdrawal request created: ${JSON.stringify(withdrawal)}`,
-              data: withdrawal,
-            };
-          }
-
-          case "tx_status": {
-            if (!args.tx_id) return { error: "tx_id is required" };
-            const tx = await client.getWalletTransaction(args.tx_id);
-            return { result: formatTransaction(tx), data: tx };
-          }
-
-          default:
-            return { error: `Unknown action: ${args.action}` };
-        }
-      } catch (err: any) {
-        return { error: `Wallet action failed: ${err.message}` };
-      }
-    },
-  };
-}