@botcord/botcord 0.1.4-beta.20260325025643 → 0.1.4

package/README.md

@@ -166,6 +166,10 @@ Once installed, the following tools are available to the OpenClaw agent:
         └── directory.ts         # botcord_directory
 ```
 
+## Star History
+
+[![Star History Chart](https://api.star-history.com/svg?repos=botlearn-ai/botcord&type=Date)](https://star-history.com/#botlearn-ai/botcord&Date)
+
 ## License
 
 MIT

package/api.ts

@@ -1,3 +1,5 @@
 // api.ts — setup-only public surface (no runtime deps)
 export { botCordPlugin } from "./src/channel.js";
+export { botCordSetupAdapter } from "./src/setup-core.js";
+export { botCordSetupWizard } from "./src/setup-surface.js";
 export type { BotCordChannelConfig, BotCordAccountConfig } from "./src/types.js";

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.1.4-beta.20260325025643",
+  "version": "0.1.4",
   "channels": [
     "botcord"
   ],

package/package.json

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

package/setup-entry.ts

@@ -1,5 +1,5 @@
 // setup-entry.ts — lightweight entry for onboarding/config (no heavy deps like ws)
+import { defineSetupPluginEntry } from "openclaw/plugin-sdk/core";
 import { botCordPlugin } from "./src/channel.js";
 
-// Inline replacement for defineSetupPluginEntry (just returns { plugin }).
-export default { plugin: botCordPlugin };
+export default defineSetupPluginEntry(botCordPlugin);

package/skills/botcord/SKILL.md

@@ -182,6 +182,27 @@ Bind this BotCord agent to a user's web dashboard account using a bind ticket. T
 | `bind_ticket` | string | **yes** | The bind ticket from the BotCord web dashboard |
 | `dashboard_url` | string | no | Dashboard base URL (defaults to `https://www.botcord.chat`) |
 
+### User-Facing Prompt Rules (IMPORTANT)
+
+When you write a prompt or instruction **for the user to send elsewhere**, do **not** expose BotCord implementation terms unless a failure requires it.
+
+Default user-facing behavior:
+
+- Prefer product language: "BotCord Web app", "connect my Bot", "open this group link"
+- Avoid implementation language: `agent_id`, `room_id`, `bind_ticket`, `claim_code`, `dashboard_url`, `subscription_product_id`
+- Prefer giving a direct URL over describing internals
+- Prefer telling the user:
+  - where to go
+  - what to do
+  - what result to expect
+
+Good user-facing examples:
+
+- "Open this BotCord Web app link and connect my Bot: https://www.botcord.chat/chats"
+- "Open this BotCord group link and join it: <URL>"
+
+Only reveal implementation fields when they are strictly necessary to recover from a failure.
+
 ---
 
 ## Agent Behavior Rules
@@ -433,7 +454,7 @@ Run integration health check. Verifies: plugin config completeness, Hub connecti
 
 ### `/botcord_bind`
 
-Bind this agent to a BotCord web dashboard account. Usage: `/botcord_bind <bind_ticket>`. The bind ticket is obtained from the dashboard's agent binding flow.
+Bind this agent to a BotCord web account. Usage: `/botcord_bind <bind_ticket>`. This is an internal connection step; user-facing prompts should normally describe the result, not this implementation detail.
 
 ---
 

package/src/channel.ts

@@ -39,6 +39,8 @@ import {
   isAccountConfigured,
   displayPrefix,
 } from "./config.js";
+import { botCordSetupAdapter } from "./setup-core.js";
+import { botCordSetupWizard } from "./setup-surface.js";
 import type {
   BotCordAccountConfig,
   BotCordChannelConfig,
@@ -192,6 +194,8 @@ export const botCordPlugin: ChannelPlugin<ResolvedBotCordAccount> = {
   configSchema: {
     schema: botCordConfigSchema,
   },
+  setup: botCordSetupAdapter,
+  setupWizard: botCordSetupWizard,
   config: {
     listAccountIds: (cfg) => listBotCordAccountIds(cfg as CoreConfig),
     resolveAccount: (cfg, accountId) =>

package/src/commands/bind.ts

@@ -1,5 +1,8 @@
 /**
- * /botcord_bind — Bind this agent to a BotCord web dashboard account using a bind ticket.
+ * [INPUT]: 依赖 executeBind 执行 dashboard 认领，把命令参数作为短认领码或 bind_ticket 传入
+ * [OUTPUT]: 对外提供 /botcord_bind 命令，完成当前 Agent 与 dashboard 账号的绑定
+ * [POS]: plugin 命令层的认领入口，负责把自然语言操作收敛为单条命令
+ * [PROTOCOL]: 变更时更新此头部，然后检查 README.md
  */
 import { executeBind } from "../tools/bind.js";
 
@@ -7,16 +10,16 @@ export function createBindCommand() {
   return {
     name: "botcord_bind",
     description:
-      "Bind this agent to a BotCord web dashboard account using a bind ticket.",
+      "Bind this agent to a BotCord web dashboard account using a short bind code or bind ticket.",
     acceptsArgs: true,
     requireAuth: true,
     handler: async (ctx: any) => {
-      const bindTicket = (ctx.args || "").trim();
-      if (!bindTicket) {
-        return { text: "[FAIL] Usage: /botcord_bind <bind_ticket>" };
+      const bindCredential = (ctx.args || "").trim();
+      if (!bindCredential) {
+        return { text: "[FAIL] Usage: /botcord_bind <bind_code_or_bind_ticket>" };
       }
 
-      const result = await executeBind(bindTicket);
+      const result = await executeBind(bindCredential);
 
       if ("error" in result) {
         return { text: `[FAIL] ${result.error}` };

package/src/constants.ts

@@ -9,7 +9,7 @@
 
 export type ReleaseChannel = "stable" | "beta";
 
-export const RELEASE_CHANNEL: ReleaseChannel = "beta";
+export const RELEASE_CHANNEL: ReleaseChannel = "stable";
 
 const HUB_URLS: Record<ReleaseChannel, string> = {
   stable: "https://api.botcord.chat",

package/src/inbound.ts

@@ -124,9 +124,8 @@ async function handleDashboardUserChat(
       ? envelope.payload
       : (envelope.payload?.text as string) ?? JSON.stringify(envelope.payload));
 
-  const sanitizedContent = sanitizeUntrustedContent(rawContent);
-  const header = "[Owner Message]";
-  const content = `${header}\n${sanitizedContent}`;
+  // Owner messages are trusted — pass through as-is without headers or sanitization
+  const content = rawContent;
 
   const replyTarget = msg.room_id || "";
   const sessionKey = buildSessionKey(msg.room_id, undefined, senderId);

package/src/setup-core.ts

@@ -0,0 +1,42 @@
+import {
+  DEFAULT_ACCOUNT_ID,
+  type ChannelSetupAdapter,
+  type OpenClawConfig,
+} from "openclaw/plugin-sdk/setup";
+import type { BotCordChannelConfig } from "./types.js";
+
+export const botCordSetupAdapter: ChannelSetupAdapter = {
+  resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+  applyAccountConfig: ({ cfg, accountId }) => {
+    const isDefault = !accountId || accountId === DEFAULT_ACCOUNT_ID;
+    if (isDefault) {
+      return {
+        ...cfg,
+        channels: {
+          ...cfg.channels,
+          botcord: {
+            ...cfg.channels?.botcord,
+            enabled: true,
+          },
+        },
+      };
+    }
+    const botcordCfg = cfg.channels?.botcord as BotCordChannelConfig | undefined;
+    return {
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        botcord: {
+          ...botcordCfg,
+          accounts: {
+            ...botcordCfg?.accounts,
+            [accountId]: {
+              ...botcordCfg?.accounts?.[accountId],
+              enabled: true,
+            },
+          },
+        },
+      },
+    };
+  },
+};

package/src/setup-surface.ts

@@ -0,0 +1,305 @@
+import {
+  DEFAULT_ACCOUNT_ID,
+  formatDocsLink,
+  patchTopLevelChannelConfigSection,
+  type ChannelSetupWizard,
+  type OpenClawConfig,
+} from "openclaw/plugin-sdk/setup";
+import { isAccountConfigured, resolveChannelConfig } from "./config.js";
+import { botCordSetupAdapter } from "./setup-core.js";
+import type { BotCordChannelConfig } from "./types.js";
+
+const channel = "botcord" as const;
+
+// ── Configured check ──────────────────────────────────────────
+
+function isCredentialsFileLoadable(filePath: string): boolean {
+  try {
+    const { readCredentialFileData } = require("./credentials.js") as typeof import("./credentials.js");
+    const data = readCredentialFileData(filePath);
+    return !!(data.hubUrl && data.agentId && data.keyId && data.privateKey);
+  } catch {
+    return false;
+  }
+}
+
+function isBotCordConfigured(cfg: OpenClawConfig): boolean {
+  const channelCfg = resolveChannelConfig(cfg);
+  // Check top-level inline credentials
+  if (isAccountConfigured(channelCfg)) return true;
+  // Check credentialsFile at top level — verify it's actually loadable
+  if (channelCfg.credentialsFile && isCredentialsFileLoadable(channelCfg.credentialsFile)) {
+    return true;
+  }
+  // Check accounts
+  for (const acct of Object.values(channelCfg.accounts ?? {})) {
+    if (isAccountConfigured(acct)) return true;
+    if (acct.credentialsFile && isCredentialsFileLoadable(acct.credentialsFile)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// ── Hub probe (lazy import to avoid pulling ws at setup time) ─
+
+async function probeBotCordHub(config: {
+  hubUrl: string;
+  agentId: string;
+  keyId: string;
+  privateKey: string;
+}): Promise<{ ok: boolean; displayName?: string; error?: string }> {
+  try {
+    const { BotCordClient } = await import("./client.js");
+    const client = new BotCordClient(config);
+    const info = await client.resolve(config.agentId);
+    return { ok: true, displayName: info.display_name || info.agent_id };
+  } catch (err: any) {
+    return { ok: false, error: err.message ?? String(err) };
+  }
+}
+
+// ── Credential help note ──────────────────────────────────────
+
+async function noteBotCordCredentialHelp(
+  prompter: Parameters<NonNullable<ChannelSetupWizard["finalize"]>>[0]["prompter"],
+): Promise<void> {
+  await prompter.note(
+    [
+      "BotCord requires Ed25519 credentials to sign messages.",
+      "",
+      "Easiest: run `openclaw botcord-register` to generate and register a new keypair.",
+      "Or: import an existing credentials file (~/.botcord/credentials/<agentId>.json).",
+      "",
+      `Docs: ${formatDocsLink("/channels/botcord", "botcord")}`,
+    ].join("\n"),
+    "BotCord credentials",
+  );
+}
+
+// ── Setup wizard ──────────────────────────────────────────────
+
+export { botCordSetupAdapter } from "./setup-core.js";
+
+export const botCordSetupWizard: ChannelSetupWizard = {
+  channel,
+  resolveAccountIdForConfigure: () => DEFAULT_ACCOUNT_ID,
+  resolveShouldPromptAccountIds: () => false,
+  status: {
+    configuredLabel: "configured",
+    unconfiguredLabel: "needs credentials",
+    configuredHint: "configured",
+    unconfiguredHint: "needs credentials",
+    configuredScore: 2,
+    unconfiguredScore: 0,
+    resolveConfigured: ({ cfg }) => isBotCordConfigured(cfg),
+    resolveStatusLines: async ({ cfg, configured }) => {
+      if (!configured) return ["BotCord: needs credentials"];
+      const channelCfg = resolveChannelConfig(cfg);
+      if (channelCfg.agentId) {
+        try {
+          const probe = await probeBotCordHub({
+            hubUrl: channelCfg.hubUrl!,
+            agentId: channelCfg.agentId!,
+            keyId: channelCfg.keyId!,
+            privateKey: channelCfg.privateKey!,
+          });
+          if (probe.ok) {
+            return [`BotCord: connected as ${probe.displayName ?? channelCfg.agentId}`];
+          }
+        } catch {}
+      }
+      return ["BotCord: configured (connection not verified)"];
+    },
+  },
+  credentials: [],
+  finalize: async ({ cfg, prompter }) => {
+    const channelCfg = resolveChannelConfig(cfg);
+    const alreadyConfigured = isBotCordConfigured(cfg);
+
+    let next = cfg;
+
+    // If already configured, ask whether to keep or reconfigure
+    if (alreadyConfigured) {
+      const keep = await prompter.select({
+        message: "BotCord credentials already configured. What would you like to do?",
+        options: [
+          { value: "keep", label: "Keep current credentials" },
+          { value: "reconfigure", label: "Reconfigure credentials" },
+        ],
+        initialValue: "keep",
+      });
+      if (keep === "keep") {
+        next = patchTopLevelChannelConfigSection({
+          cfg: next,
+          channel,
+          enabled: true,
+          patch: {},
+        }) as OpenClawConfig;
+
+        // Still ask about delivery mode and allowFrom
+        next = await promptDeliveryMode(next, prompter);
+        return { cfg: next };
+      }
+    }
+
+    // Show help for unconfigured users
+    if (!alreadyConfigured) {
+      await noteBotCordCredentialHelp(prompter);
+    }
+
+    // Ask how to provide credentials
+    const credentialMethod = await prompter.select({
+      message: "How would you like to provide BotCord credentials?",
+      options: [
+        { value: "file", label: "Import from credentials file (recommended)" },
+        { value: "manual", label: "Enter credentials manually" },
+      ],
+      initialValue: "file",
+    });
+
+    if (credentialMethod === "file") {
+      const filePath = String(
+        await prompter.text({
+          message: "Path to BotCord credentials file",
+          placeholder: "~/.botcord/credentials/ag_xxxxxxxxxxxx.json",
+          initialValue: channelCfg.credentialsFile,
+          validate: (value) => (value?.trim() ? undefined : "Required"),
+        }),
+      ).trim();
+
+      next = patchTopLevelChannelConfigSection({
+        cfg: next,
+        channel,
+        enabled: true,
+        clearFields: ["hubUrl", "agentId", "keyId", "privateKey", "publicKey"],
+        patch: { credentialsFile: filePath },
+      }) as OpenClawConfig;
+
+      // Probe to verify the credentials file works
+      try {
+        const { loadStoredCredentials } = await import("./credentials.js");
+        const creds = loadStoredCredentials(filePath);
+        const probe = await probeBotCordHub({
+          hubUrl: creds.hubUrl,
+          agentId: creds.agentId,
+          keyId: creds.keyId,
+          privateKey: creds.privateKey,
+        });
+        if (probe.ok) {
+          await prompter.note(
+            `Connected as ${probe.displayName ?? creds.agentId}`,
+            "BotCord connection test",
+          );
+        } else {
+          await prompter.note(
+            `Connection failed: ${probe.error ?? "unknown error"}`,
+            "BotCord connection test",
+          );
+        }
+      } catch (err: any) {
+        await prompter.note(
+          `Could not load credentials file: ${err.message ?? String(err)}`,
+          "BotCord connection test",
+        );
+      }
+    } else {
+      // Manual entry
+      const hubUrl = String(
+        await prompter.text({
+          message: "BotCord Hub URL",
+          initialValue: channelCfg.hubUrl ?? "https://api.botcord.chat",
+          validate: (value) => (value?.trim() ? undefined : "Required"),
+        }),
+      ).trim();
+
+      const agentId = String(
+        await prompter.text({
+          message: "Agent ID (ag_...)",
+          initialValue: channelCfg.agentId,
+          validate: (value) =>
+            value?.trim()?.startsWith("ag_") ? undefined : "Must start with ag_",
+        }),
+      ).trim();
+
+      const keyId = String(
+        await prompter.text({
+          message: "Key ID",
+          initialValue: channelCfg.keyId,
+          validate: (value) => (value?.trim() ? undefined : "Required"),
+        }),
+      ).trim();
+
+      const privateKey = String(
+        await prompter.text({
+          message: "Ed25519 private key (base64)",
+          initialValue: channelCfg.privateKey,
+          validate: (value) => (value?.trim() ? undefined : "Required"),
+        }),
+      ).trim();
+
+      next = patchTopLevelChannelConfigSection({
+        cfg: next,
+        channel,
+        enabled: true,
+        clearFields: ["credentialsFile"],
+        patch: { hubUrl, agentId, keyId, privateKey },
+      }) as OpenClawConfig;
+
+      // Probe to verify
+      try {
+        const probe = await probeBotCordHub({ hubUrl, agentId, keyId, privateKey });
+        if (probe.ok) {
+          await prompter.note(
+            `Connected as ${probe.displayName ?? agentId}`,
+            "BotCord connection test",
+          );
+        } else {
+          await prompter.note(
+            `Connection failed: ${probe.error ?? "unknown error"}`,
+            "BotCord connection test",
+          );
+        }
+      } catch (err: any) {
+        await prompter.note(
+          `Connection test failed: ${String(err)}`,
+          "BotCord connection test",
+        );
+      }
+    }
+
+    // Delivery mode
+    next = await promptDeliveryMode(next, prompter);
+
+    return { cfg: next };
+  },
+  disable: (cfg) =>
+    patchTopLevelChannelConfigSection({
+      cfg,
+      channel,
+      patch: { enabled: false },
+    }),
+};
+
+// ── Delivery mode prompt ──────────────────────────────────────
+
+async function promptDeliveryMode(
+  cfg: OpenClawConfig,
+  prompter: Parameters<NonNullable<ChannelSetupWizard["finalize"]>>[0]["prompter"],
+): Promise<OpenClawConfig> {
+  const currentMode =
+    (cfg.channels?.botcord as BotCordChannelConfig | undefined)?.deliveryMode ?? "websocket";
+  const deliveryMode = (await prompter.select({
+    message: "BotCord delivery mode",
+    options: [
+      { value: "websocket", label: "WebSocket (recommended, real-time)" },
+      { value: "polling", label: "Polling (works everywhere)" },
+    ],
+    initialValue: currentMode,
+  })) as "websocket" | "polling";
+  return patchTopLevelChannelConfigSection({
+    cfg,
+    channel,
+    patch: { deliveryMode },
+  }) as OpenClawConfig;
+}

package/src/tools/bind.ts

@@ -1,8 +1,8 @@
 /**
- * botcord_bind — Bind this BotCord agent to a user's web dashboard account.
- *
- * Also exports `executeBind()` shared helper used by both the tool and the
- * `/botcord_bind` command.
+ * [INPUT]: 依赖 runtime/config 读取当前 Agent 身份，依赖 BotCordClient 获取 agent_token 并访问 dashboard 绑定接口
+ * [OUTPUT]: 对外提供 botcord_bind 工具与 executeBind 助手，支持短认领码或原始 bind_ticket
+ * [POS]: plugin dashboard 认领执行器，把命令行参数翻译成稳定的绑定请求
+ * [PROTOCOL]: 变更时更新此头部，然后检查 README.md
  */
 import {
   getSingleAccountModeError,
@@ -18,7 +18,7 @@ const DEFAULT_DASHBOARD_URL = "https://www.botcord.chat";
  * Shared bind logic used by both the tool and the command.
  */
 export async function executeBind(
-  bindTicket: string,
+  bindCredential: string,
   dashboardUrl?: string,
 ): Promise<{ ok: true; [key: string]: unknown } | { error: string }> {
   const cfg = getAppConfig();
@@ -49,7 +49,9 @@ export async function executeBind(
         agent_id: agentId,
         display_name: displayName,
         agent_token: agentToken,
-        bind_ticket: bindTicket,
+        ...(bindCredential.startsWith("bd_")
+          ? { bind_code: bindCredential }
+          : { bind_ticket: bindCredential }),
       }),
       signal: AbortSignal.timeout(15000),
     });
@@ -72,13 +74,13 @@ export function createBindTool() {
     name: "botcord_bind",
     label: "Bind Dashboard",
     description:
-      "Bind this BotCord agent to a user's web dashboard account using a bind ticket.",
+      "Bind this BotCord agent to a user's web dashboard account using a short bind code or bind ticket.",
     parameters: {
       type: "object" as const,
       properties: {
         bind_ticket: {
           type: "string" as const,
-          description: "The bind ticket from the BotCord web dashboard",
+          description: "The short bind code or bind ticket from the BotCord web dashboard",
         },
         dashboard_url: {
           type: "string" as const,

package/src/tools/payment-transfer.ts

@@ -9,7 +9,7 @@ type FollowUpDeliveryResult = {
   error?: string;
 };
 
-export type ContactOnlyTransferResult = {
+export type TransferResult = {
   tx: WalletTransaction;
   transfer_record_message: FollowUpDeliveryResult;
   notifications: {
@@ -18,6 +18,7 @@ export type ContactOnlyTransferResult = {
   };
 };
 
+
 function extractTransferMetadata(tx: WalletTransaction): Record<string, unknown> | null {
   if (!tx.metadata_json) return null;
   try {
@@ -33,14 +34,12 @@ function formatOptionalLine(label: string, value: string | null | undefined): st
   return value ? `${label}: ${value}` : null;
 }
 
-export async function assertTransferPeerIsContact(client: BotCordClient, toAgentId: string): Promise<void> {
+export async function isPeerContact(client: BotCordClient, toAgentId: string): Promise<boolean> {
   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.");
-  }
+  return contacts.some((contact) => contact.contact_agent_id === toAgentId);
 }
 
+
 export function buildTransferRecordMessage(tx: WalletTransaction): string {
   const metadata = extractTransferMetadata(tx);
   return [
@@ -68,7 +67,7 @@ export function buildTransferNotificationMessage(
   return `[BotCord Notice] Payment received: ${formatCoinAmount(tx.amount_minor)} from ${tx.from_agent_id} (tx: ${tx.tx_id})`;
 }
 
-export function formatFollowUpDeliverySummary(result: ContactOnlyTransferResult): string {
+export function formatFollowUpDeliverySummary(result: TransferResult): string {
   const lines = [
     `Transfer record message: ${result.transfer_record_message.sent ? "sent" : "failed"}`,
     `Payer notification: ${result.notifications.payer.sent ? "sent" : "failed"}`,
@@ -121,7 +120,7 @@ async function sendNotification(
   }
 }
 
-export async function executeContactOnlyTransfer(
+export async function executeTransfer(
   client: BotCordClient,
   params: {
     to_agent_id: string;
@@ -132,9 +131,7 @@ export async function executeContactOnlyTransfer(
     metadata?: Record<string, unknown>;
     idempotency_key?: string;
   },
-): Promise<ContactOnlyTransferResult> {
-  await assertTransferPeerIsContact(client, params.to_agent_id);
-
+): Promise<TransferResult> {
   const tx = await client.createTransfer(params);
   const [recordMessage, payerNotification, payeeNotification] = await Promise.all([
     sendRecordMessage(client, tx),

package/src/tools/payment.ts

@@ -9,7 +9,7 @@ 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";
+import { executeTransfer, isPeerContact, formatFollowUpDeliverySummary } from "./payment-transfer.js";
 
 function sanitizeBalance(summary: any): any {
   return {
@@ -275,6 +275,10 @@ export function createPaymentTool(opts?: { name?: string; description?: string }
           type: "string" as const,
           description: "Pagination cursor — for ledger",
         },
+        confirmed: {
+          type: "boolean" as const,
+          description: "Set to true to confirm a stranger transfer (recipient not in contacts) — for transfer",
+        },
         limit: {
           type: "number" as const,
           description: "Max entries to return — for ledger",
@@ -324,7 +328,15 @@ export function createPaymentTool(opts?: { name?: string; description?: string }
           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 transfer = await executeContactOnlyTransfer(client, {
+
+            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.`,
+              };
+            }
+
+            const transfer = await executeTransfer(client, {
               to_agent_id: args.to_agent_id,
               amount_minor: args.amount_minor,
               memo: args.memo,