@botcord/botcord 0.2.2 → 0.2.4-beta.20260329125010

package/src/tools/payment.ts

@@ -1,14 +1,8 @@
 /**
  * botcord_payment — Unified payment and transaction tool for BotCord coin flows.
  */
-import {
-  getSingleAccountModeError,
-  resolveAccountConfig,
-  isAccountConfigured,
-} from "../config.js";
-import { BotCordClient } from "../client.js";
-import { attachTokenPersistence } from "../credentials.js";
-import { getConfig as getAppConfig } from "../runtime.js";
+import { withClient } from "./with-client.js";
+import { validationError, dryRunResult } from "./tool-result.js";
 import { formatCoinAmount } from "./coin-format.js";
 import { executeTransfer, isPeerContact, formatFollowUpDeliverySummary } from "./payment-transfer.js";
 
@@ -288,34 +282,46 @@ export function createPaymentTool(opts?: { name?: string; description?: string }
           type: "string" as const,
           description: "Filter by transaction type — for ledger",
         },
+        dry_run: {
+          type: "boolean" as const,
+          description: "Preview the request without executing. Returns the API call that would be made.",
+        },
       },
       required: ["action"],
     },
     execute: async (_toolCallId: any, args: 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);
-      attachTokenPersistence(client, acct);
+      return withClient(async (client) => {
+        // Dry-run for write operations
+        if (args.dry_run) {
+          switch (args.action) {
+            case "transfer":
+              if (!args.to_agent_id) return validationError("to_agent_id is required");
+              if (!args.amount_minor) return validationError("amount_minor is required");
+              return dryRunResult("POST", "/wallet/transfers", { to_agent_id: args.to_agent_id, amount_minor: args.amount_minor, memo: args.memo }) as any;
+            case "topup":
+              if (!args.amount_minor) return validationError("amount_minor is required");
+              return dryRunResult("POST", "/wallet/topups", { amount_minor: args.amount_minor, channel: args.channel }) as any;
+            case "withdraw":
+              if (!args.amount_minor) return validationError("amount_minor is required");
+              return dryRunResult("POST", "/wallet/withdrawals", { amount_minor: args.amount_minor, destination_type: args.destination_type }) as any;
+            case "cancel_withdrawal":
+              if (!args.withdrawal_id) return validationError("withdrawal_id is required");
+              return dryRunResult("POST", `/wallet/withdrawals/${args.withdrawal_id}/cancel`) as any;
+            default:
+              break;
+          }
+        }
 
-      try {
         switch (args.action) {
           case "recipient_verify": {
-            if (!args.agent_id) return { error: "agent_id is required" };
+            if (!args.agent_id) return validationError("agent_id is required");
             const agent = await client.resolve(args.agent_id);
-            return { result: formatRecipient(agent), data: agent };
+            return { result: formatRecipient(agent), data: agent } as any;
           }
 
           case "balance": {
             const summary = await client.getWallet();
-            return { result: formatBalance(summary), data: sanitizeBalance(summary) };
+            return { result: formatBalance(summary), data: sanitizeBalance(summary) } as any;
           }
 
           case "ledger": {
@@ -324,18 +330,18 @@ export function createPaymentTool(opts?: { name?: string; description?: string }
             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: sanitizeLedger(ledger) };
+            return { result: formatLedger(ledger), data: sanitizeLedger(ledger) } as any;
           }
 
           case "transfer": {
-            if (!args.to_agent_id) return { error: "to_agent_id is required" };
-            if (!args.amount_minor) return { error: "amount_minor is required" };
+            if (!args.to_agent_id) return validationError("to_agent_id is required");
+            if (!args.amount_minor) return validationError("amount_minor is required");
 
             const isContact = await isPeerContact(client, args.to_agent_id);
             if (!isContact && args.confirmed !== true) {
               return {
                 result: `\u26a0\ufe0f ${args.to_agent_id} is not in your contacts. This is a stranger transfer of ${formatCoinAmount(args.amount_minor)}. To proceed, call this tool again with confirmed: true. The transfer will create a chat room between you and the recipient.`,
-              };
+              } as any;
             }
 
             const transfer = await executeTransfer(client, {
@@ -350,22 +356,22 @@ export function createPaymentTool(opts?: { name?: string; description?: string }
             return {
               result: `${formatTransaction(transfer.tx)}\n${formatFollowUpDeliverySummary(transfer)}`,
               data: sanitizeTransferResult(transfer),
-            };
+            } as any;
           }
 
           case "topup": {
-            if (!args.amount_minor) return { error: "amount_minor is required" };
+            if (!args.amount_minor) return validationError("amount_minor is required");
             const topup = await client.createTopup({
               amount_minor: args.amount_minor,
               channel: args.channel,
               metadata: args.metadata,
               idempotency_key: args.idempotency_key,
             });
-            return { result: formatTopup(topup), data: sanitizeTopup(topup) };
+            return { result: formatTopup(topup), data: sanitizeTopup(topup) } as any;
           }
 
           case "withdraw": {
-            if (!args.amount_minor) return { error: "amount_minor is required" };
+            if (!args.amount_minor) return validationError("amount_minor is required");
             const withdrawal = await client.createWithdrawal({
               amount_minor: args.amount_minor,
               fee_minor: args.fee_minor,
@@ -373,27 +379,25 @@ export function createPaymentTool(opts?: { name?: string; description?: string }
               destination: args.destination,
               idempotency_key: args.idempotency_key,
             });
-            return { result: formatWithdrawal(withdrawal), data: sanitizeWithdrawal(withdrawal) };
+            return { result: formatWithdrawal(withdrawal), data: sanitizeWithdrawal(withdrawal) } as any;
           }
 
           case "cancel_withdrawal": {
-            if (!args.withdrawal_id) return { error: "withdrawal_id is required" };
+            if (!args.withdrawal_id) return validationError("withdrawal_id is required");
             const withdrawal = await client.cancelWithdrawal(args.withdrawal_id);
-            return { result: formatWithdrawal(withdrawal), data: sanitizeWithdrawal(withdrawal) };
+            return { result: formatWithdrawal(withdrawal), data: sanitizeWithdrawal(withdrawal) } as any;
           }
 
           case "tx_status": {
-            if (!args.tx_id) return { error: "tx_id is required" };
+            if (!args.tx_id) return validationError("tx_id is required");
             const tx = await client.getWalletTransaction(args.tx_id);
-            return { result: formatTransaction(tx), data: sanitizeTransaction(tx) };
+            return { result: formatTransaction(tx), data: sanitizeTransaction(tx) } as any;
           }
 
           default:
-            return { error: `Unknown action: ${args.action}` };
+            return validationError(`Unknown action: ${args.action}`);
         }
-      } catch (err: any) {
-        return { error: `Payment action failed: ${err.message}` };
-      }
+      });
     },
   };
 }

package/src/tools/register.ts

@@ -4,6 +4,7 @@
 import { registerAgent } from "../commands/register.js";
 import { getConfig as getAppConfig } from "../runtime.js";
 import { DEFAULT_HUB } from "../constants.js";
+import { validationError, configError, classifyError } from "./tool-result.js";
 
 export function createRegisterTool() {
   return {
@@ -35,11 +36,11 @@ export function createRegisterTool() {
     },
     execute: async (toolCallId: any, args: any, signal?: any, onUpdate?: any) => {
       if (!args.name) {
-        return { error: "name is required" };
+        return validationError("name is required");
       }
 
       const cfg = getAppConfig();
-      if (!cfg) return { error: "No configuration available" };
+      if (!cfg) return configError("No configuration available");
 
       try {
         const result = await registerAgent({
@@ -59,8 +60,8 @@ export function createRegisterTool() {
           claim_url: result.claimUrl,
           note: "Restart OpenClaw to activate: openclaw gateway restart",
         };
-      } catch (err: any) {
-        return { error: `Registration failed: ${err.message}` };
+      } catch (err: unknown) {
+        return classifyError(err);
       }
     },
   };

package/src/tools/reset-credential.ts

@@ -3,6 +3,7 @@
  */
 import { getConfig as getAppConfig } from "../runtime.js";
 import { resetCredential } from "../reset-credential.js";
+import { validationError, configError, classifyError } from "./tool-result.js";
 
 export function createResetCredentialTool() {
   return {
@@ -30,9 +31,9 @@ export function createResetCredentialTool() {
     },
     execute: async (_toolCallId: any, args: any) => {
       const cfg = getAppConfig();
-      if (!cfg) return { error: "No configuration available" };
-      if (!args.agent_id) return { error: "agent_id is required" };
-      if (!args.reset_code) return { error: "reset_code is required" };
+      if (!cfg) return configError("No configuration available");
+      if (!args.agent_id) return validationError("agent_id is required");
+      if (!args.reset_code) return validationError("reset_code is required");
 
       try {
         const result = await resetCredential({
@@ -50,8 +51,8 @@ export function createResetCredentialTool() {
           credentials_file: result.credentialsFile,
           note: "Restart OpenClaw to activate: openclaw gateway restart",
         };
-      } catch (err: any) {
-        return { error: err.message };
+      } catch (err: unknown) {
+        return classifyError(err);
       }
     },
   };

package/src/tools/rooms.ts

@@ -1,14 +1,8 @@
 /**
  * botcord_rooms — Room lifecycle and membership management.
  */
-import {
-  getSingleAccountModeError,
-  resolveAccountConfig,
-  isAccountConfigured,
-} from "../config.js";
-import { BotCordClient } from "../client.js";
-import { attachTokenPersistence } from "../credentials.js";
-import { getConfig as getAppConfig } from "../runtime.js";
+import { withClient } from "./with-client.js";
+import { validationError, dryRunResult } from "./tool-result.js";
 
 export function createRoomsTool() {
   return {
@@ -102,27 +96,60 @@ export function createRoomsTool() {
           type: "boolean" as const,
           description: "Mute or unmute the current member in a room — for mute",
         },
+        dry_run: {
+          type: "boolean" as const,
+          description: "Preview the request without executing. Returns the API call that would be made.",
+        },
       },
       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);
-      attachTokenPersistence(client, acct);
+      return withClient(async (client) => {
+        // Dry-run for write operations
+        if (args.dry_run) {
+          switch (args.action) {
+            case "create":
+              if (!args.name) return validationError("name is required");
+              return dryRunResult("POST", "/hub/rooms", { name: args.name, visibility: args.visibility || "private", join_policy: args.join_policy, member_ids: args.member_ids }) as any;
+            case "update":
+              if (!args.room_id) return validationError("room_id is required");
+              return dryRunResult("PATCH", `/hub/rooms/${args.room_id}`, { name: args.name, description: args.description, visibility: args.visibility }) as any;
+            case "dissolve":
+              if (!args.room_id) return validationError("room_id is required");
+              return dryRunResult("DELETE", `/hub/rooms/${args.room_id}`) as any;
+            case "join":
+              if (!args.room_id) return validationError("room_id is required");
+              return dryRunResult("POST", `/hub/rooms/${args.room_id}/members`, { agent_id: "{self}" }) as any;
+            case "invite":
+              if (!args.room_id || !args.agent_id) return validationError("room_id and agent_id are required");
+              return dryRunResult("POST", `/hub/rooms/${args.room_id}/members`, { agent_id: args.agent_id, can_send: args.can_send, can_invite: args.can_invite }) as any;
+            case "remove_member":
+              if (!args.room_id || !args.agent_id) return validationError("room_id and agent_id are required");
+              return dryRunResult("DELETE", `/hub/rooms/${args.room_id}/members/${args.agent_id}`) as any;
+            case "promote":
+              if (!args.room_id || !args.agent_id) return validationError("room_id and agent_id are required");
+              return dryRunResult("POST", `/hub/rooms/${args.room_id}/promote`, { agent_id: args.agent_id, role: args.role || "admin" }) as any;
+            case "transfer":
+              if (!args.room_id || !args.agent_id) return validationError("room_id and agent_id are required");
+              return dryRunResult("POST", `/hub/rooms/${args.room_id}/transfer`, { new_owner_id: args.agent_id }) as any;
+            case "permissions":
+              if (!args.room_id || !args.agent_id) return validationError("room_id and agent_id are required");
+              return dryRunResult("POST", `/hub/rooms/${args.room_id}/permissions`, { agent_id: args.agent_id, can_send: args.can_send, can_invite: args.can_invite }) as any;
+            case "leave":
+              if (!args.room_id) return validationError("room_id is required");
+              return dryRunResult("POST", `/hub/rooms/${args.room_id}/leave`) as any;
+            case "mute":
+              if (!args.room_id) return validationError("room_id is required");
+              return dryRunResult("POST", `/hub/rooms/${args.room_id}/mute`, { muted: args.muted ?? true }) as any;
+            default:
+              // Read actions don't support dry-run, fall through to normal execution
+              break;
+          }
+        }
 
-      try {
         switch (args.action) {
           case "create":
-            if (!args.name) return { error: "name is required" };
+            if (!args.name) return validationError("name is required");
             return await client.createRoom({
               name: args.name,
               description: args.description,
@@ -138,14 +165,14 @@ export function createRoomsTool() {
             });
 
           case "list":
-            return await client.listMyRooms();
+            return { rooms: await client.listMyRooms() } as any;
 
           case "info":
-            if (!args.room_id) return { error: "room_id is required" };
+            if (!args.room_id) return validationError("room_id is required");
             return await client.getRoomInfo(args.room_id);
 
           case "update":
-            if (!args.room_id) return { error: "room_id is required" };
+            if (!args.room_id) return validationError("room_id is required");
             return await client.updateRoom(args.room_id, {
               name: args.name,
               description: args.description,
@@ -160,72 +187,70 @@ export function createRoomsTool() {
             });
 
           case "discover":
-            return await client.discoverRooms(args.name);
+            return { rooms: await client.discoverRooms(args.name) } as any;
 
           case "join":
-            if (!args.room_id) return { error: "room_id is required" };
+            if (!args.room_id) return validationError("room_id is required");
             await client.joinRoom(args.room_id, {
               can_send: args.can_send,
               can_invite: args.can_invite,
             });
-            return { ok: true, joined: args.room_id };
+            return { ok: true, joined: args.room_id } as any;
 
           case "leave":
-            if (!args.room_id) return { error: "room_id is required" };
+            if (!args.room_id) return validationError("room_id is required");
             await client.leaveRoom(args.room_id);
-            return { ok: true, left: args.room_id };
+            return { ok: true, left: args.room_id } as any;
 
           case "dissolve":
-            if (!args.room_id) return { error: "room_id is required" };
+            if (!args.room_id) return validationError("room_id is required");
             await client.dissolveRoom(args.room_id);
-            return { ok: true, dissolved: args.room_id };
+            return { ok: true, dissolved: args.room_id } as any;
 
           case "members":
-            if (!args.room_id) return { error: "room_id is required" };
-            return await client.getRoomMembers(args.room_id);
+            if (!args.room_id) return validationError("room_id is required");
+            return { members: await client.getRoomMembers(args.room_id) } as any;
 
           case "invite":
-            if (!args.room_id || !args.agent_id) return { error: "room_id and agent_id are required" };
+            if (!args.room_id || !args.agent_id) return validationError("room_id and agent_id are required");
             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 };
+            return { ok: true, invited: args.agent_id, room: args.room_id } as any;
 
           case "remove_member":
-            if (!args.room_id || !args.agent_id) return { error: "room_id and agent_id are required" };
+            if (!args.room_id || !args.agent_id) return validationError("room_id and agent_id are required");
             await client.removeMember(args.room_id, args.agent_id);
-            return { ok: true, removed: args.agent_id, room: args.room_id };
+            return { ok: true, removed: args.agent_id, room: args.room_id } as any;
 
           case "promote":
-            if (!args.room_id || !args.agent_id) return { error: "room_id and agent_id are required" };
+            if (!args.room_id || !args.agent_id) return validationError("room_id and agent_id are required");
             await client.promoteMember(args.room_id, args.agent_id, args.role || "admin");
-            return { ok: true, promoted: args.agent_id, role: args.role || "admin", room: args.room_id };
+            return { ok: true, promoted: args.agent_id, role: args.role || "admin", room: args.room_id } as any;
 
           case "transfer":
-            if (!args.room_id || !args.agent_id) return { error: "room_id and agent_id are required" };
+            if (!args.room_id || !args.agent_id) return validationError("room_id and agent_id are required");
             await client.transferOwnership(args.room_id, args.agent_id);
-            return { ok: true, new_owner: args.agent_id, room: args.room_id };
+            return { ok: true, new_owner: args.agent_id, room: args.room_id } as any;
 
           case "permissions":
-            if (!args.room_id || !args.agent_id) return { error: "room_id and agent_id are required" };
+            if (!args.room_id || !args.agent_id) return validationError("room_id and agent_id are required");
             await client.setMemberPermissions(args.room_id, args.agent_id, {
               can_send: args.can_send,
               can_invite: args.can_invite,
             });
-            return { ok: true, agent: args.agent_id, room: args.room_id };
+            return { ok: true, agent: args.agent_id, room: args.room_id } as any;
 
           case "mute":
-            if (!args.room_id) return { error: "room_id is required" };
+            if (!args.room_id) return validationError("room_id is required");
             await client.muteRoom(args.room_id, args.muted ?? true);
-            return { ok: true, room: args.room_id, muted: args.muted ?? true };
+            return { ok: true, room: args.room_id, muted: args.muted ?? true } as any;
 
           default:
-            return { error: `Unknown action: ${args.action}` };
+            return validationError(`Unknown action: ${args.action}`);
         }
-      } catch (err: any) {
-        return { error: `Room action failed: ${err.message}` };
-      }
+      });
     },
   };
 }

package/src/tools/subscription.ts

@@ -1,14 +1,8 @@
 /**
  * botcord_subscription — Create and manage coin-priced subscription products.
  */
-import {
-  getSingleAccountModeError,
-  resolveAccountConfig,
-  isAccountConfigured,
-} from "../config.js";
-import { BotCordClient } from "../client.js";
-import { attachTokenPersistence } from "../credentials.js";
-import { getConfig as getAppConfig } from "../runtime.js";
+import { withClient } from "./with-client.js";
+import { validationError, dryRunResult } from "./tool-result.js";
 import { formatCoinAmount } from "./coin-format.js";
 
 function formatProduct(product: any): string {
@@ -127,29 +121,50 @@ export function createSubscriptionTool() {
           type: "number" as const,
           description: "Slow mode interval in seconds — for create_subscription_room or bind_room_to_product",
         },
+        dry_run: {
+          type: "boolean" as const,
+          description: "Preview the request without executing. Returns the API call that would be made.",
+        },
       },
       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);
-      attachTokenPersistence(client, acct);
+      return withClient(async (client) => {
+        // Dry-run for write operations
+        if (args.dry_run) {
+          switch (args.action) {
+            case "create_product":
+              if (!args.name) return validationError("name is required");
+              if (!args.amount_minor) return validationError("amount_minor is required");
+              if (!args.billing_interval) return validationError("billing_interval is required");
+              return dryRunResult("POST", "/subscriptions/products", { name: args.name, amount_minor: args.amount_minor, billing_interval: args.billing_interval }) as any;
+            case "subscribe":
+              if (!args.product_id) return validationError("product_id is required");
+              return dryRunResult("POST", `/subscriptions/products/${args.product_id}/subscribe`) as any;
+            case "archive_product":
+              if (!args.product_id) return validationError("product_id is required");
+              return dryRunResult("POST", `/subscriptions/products/${args.product_id}/archive`) as any;
+            case "cancel":
+              if (!args.subscription_id) return validationError("subscription_id is required");
+              return dryRunResult("POST", `/subscriptions/${args.subscription_id}/cancel`) as any;
+            case "create_subscription_room":
+              if (!args.product_id) return validationError("product_id is required");
+              if (!args.name) return validationError("name is required");
+              return dryRunResult("POST", "/hub/rooms", { name: args.name, description: args.description, visibility: "public", join_policy: "open", required_subscription_product_id: args.product_id }) as any;
+            case "bind_room_to_product":
+              if (!args.room_id) return validationError("room_id is required");
+              if (!args.product_id) return validationError("product_id is required");
+              return dryRunResult("PATCH", `/hub/rooms/${args.room_id}`, { visibility: "public", join_policy: "open", required_subscription_product_id: args.product_id }) as any;
+            default:
+              break;
+          }
+        }
 
-      try {
         switch (args.action) {
           case "create_product": {
-            if (!args.name) return { error: "name is required" };
-            if (!args.amount_minor) return { error: "amount_minor is required" };
-            if (!args.billing_interval) return { error: "billing_interval is required" };
+            if (!args.name) return validationError("name is required");
+            if (!args.amount_minor) return validationError("amount_minor is required");
+            if (!args.billing_interval) return validationError("billing_interval is required");
             const product = await client.createSubscriptionProduct({
               name: args.name,
               description: args.description,
@@ -157,28 +172,28 @@ export function createSubscriptionTool() {
               billing_interval: args.billing_interval,
               asset_code: args.asset_code,
             });
-            return { result: formatProduct(product), data: product };
+            return { result: formatProduct(product), data: product } as any;
           }
 
           case "list_my_products": {
             const products = await client.listMySubscriptionProducts();
-            return { result: formatProductList(products), data: products };
+            return { result: formatProductList(products), data: products } as any;
           }
 
           case "list_products": {
             const products = await client.listSubscriptionProducts();
-            return { result: formatProductList(products), data: products };
+            return { result: formatProductList(products), data: products } as any;
           }
 
           case "archive_product": {
-            if (!args.product_id) return { error: "product_id is required" };
+            if (!args.product_id) return validationError("product_id is required");
             const product = await client.archiveSubscriptionProduct(args.product_id);
-            return { result: formatProduct(product), data: product };
+            return { result: formatProduct(product), data: product } as any;
           }
 
           case "create_subscription_room": {
-            if (!args.product_id) return { error: "product_id is required" };
-            if (!args.name) return { error: "name is required" };
+            if (!args.product_id) return validationError("product_id is required");
+            if (!args.name) return validationError("name is required");
             const room = await client.createRoom({
               name: args.name,
               description: args.description,
@@ -194,12 +209,12 @@ export function createSubscriptionTool() {
             return {
               result: `Subscription room created: ${room.room_id} bound to ${args.product_id}`,
               data: room,
-            };
+            } as any;
           }
 
           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" };
+            if (!args.room_id) return validationError("room_id is required");
+            if (!args.product_id) return validationError("product_id is required");
             const room = await client.updateRoom(args.room_id, {
               name: args.name,
               description: args.description,
@@ -215,38 +230,36 @@ export function createSubscriptionTool() {
             return {
               result: `Room ${room.room_id} bound to subscription product ${args.product_id}`,
               data: room,
-            };
+            } as any;
           }
 
           case "subscribe": {
-            if (!args.product_id) return { error: "product_id is required" };
+            if (!args.product_id) return validationError("product_id is required");
             const subscription = await client.subscribeToProduct(args.product_id, args.idempotency_key);
-            return { result: formatSubscription(subscription), data: subscription };
+            return { result: formatSubscription(subscription), data: subscription } as any;
           }
 
           case "list_my_subscriptions": {
             const subscriptions = await client.listMySubscriptions();
-            return { result: formatSubscriptionList(subscriptions), data: subscriptions };
+            return { result: formatSubscriptionList(subscriptions), data: subscriptions } as any;
           }
 
           case "list_subscribers": {
-            if (!args.product_id) return { error: "product_id is required" };
+            if (!args.product_id) return validationError("product_id is required");
             const subscriptions = await client.listProductSubscribers(args.product_id);
-            return { result: formatSubscriptionList(subscriptions), data: subscriptions };
+            return { result: formatSubscriptionList(subscriptions), data: subscriptions } as any;
           }
 
           case "cancel": {
-            if (!args.subscription_id) return { error: "subscription_id is required" };
+            if (!args.subscription_id) return validationError("subscription_id is required");
             const subscription = await client.cancelSubscription(args.subscription_id);
-            return { result: formatSubscription(subscription), data: subscription };
+            return { result: formatSubscription(subscription), data: subscription } as any;
           }
 
           default:
-            return { error: `Unknown action: ${args.action}` };
+            return validationError(`Unknown action: ${args.action}`);
         }
-      } catch (err: any) {
-        return { error: `Subscription action failed: ${err.message}` };
-      }
+      });
     },
   };
 }