hybrid 1.2.2 → 1.2.3

package/dist/tools/index.cjs

@@ -0,0 +1,706 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/tools/index.ts
+var tools_exports = {};
+__export(tools_exports, {
+  blockchainTools: () => blockchainTools,
+  estimateGasTool: () => estimateGasTool,
+  getBalanceTool: () => getBalanceTool,
+  getBlockTool: () => getBlockTool,
+  getGasPriceTool: () => getGasPriceTool,
+  getMessageTool: () => getMessageTool,
+  getTransactionTool: () => getTransactionTool,
+  sendMessageTool: () => sendMessageTool,
+  sendReactionTool: () => sendReactionTool,
+  sendReplyTool: () => sendReplyTool,
+  sendTransactionTool: () => sendTransactionTool,
+  xmtpTools: () => xmtpTools
+});
+module.exports = __toCommonJS(tools_exports);
+
+// src/tools/blockchain.ts
+var import_viem = require("viem");
+var import_accounts = require("viem/accounts");
+var import_chains = require("viem/chains");
+var import_zod = require("zod");
+
+// src/core/tool.ts
+function toolFactory() {
+  return (config) => {
+    return {
+      description: config.description,
+      inputSchema: config.inputSchema,
+      outputSchema: config.outputSchema,
+      execute: async (args) => {
+        const input = config.inputSchema.parse(args.input);
+        const result = await config.execute({
+          input,
+          runtime: args.runtime,
+          messages: args.messages
+        });
+        if (config.outputSchema) {
+          return config.outputSchema.parse(result);
+        }
+        return result;
+      }
+    };
+  };
+}
+var createTool = toolFactory();
+
+// src/tools/blockchain.ts
+var SUPPORTED_CHAINS = {
+  mainnet: import_chains.mainnet,
+  sepolia: import_chains.sepolia,
+  polygon: import_chains.polygon,
+  arbitrum: import_chains.arbitrum,
+  optimism: import_chains.optimism,
+  base: import_chains.base
+};
+var getBalanceTool = createTool({
+  id: "getBalance",
+  description: "Get the native token balance for a wallet address on a blockchain",
+  inputSchema: import_zod.z.object({
+    address: import_zod.z.string().describe("The wallet address to check balance for"),
+    chain: import_zod.z.enum(["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]).default("mainnet").describe("The blockchain network to check on")
+  }),
+  outputSchema: import_zod.z.object({
+    success: import_zod.z.boolean(),
+    balance: import_zod.z.string().describe("Balance in human readable format (ETH, MATIC, etc.)"),
+    balanceWei: import_zod.z.string().describe("Balance in wei (smallest unit)"),
+    address: import_zod.z.string(),
+    chain: import_zod.z.string(),
+    error: import_zod.z.string().optional()
+  }),
+  execute: async ({ input, runtime }) => {
+    try {
+      const { address, chain } = input;
+      const chainConfig = SUPPORTED_CHAINS[chain];
+      const rpcUrl = runtime.rpcUrl || chainConfig.rpcUrls.default.http[0];
+      const client = (0, import_viem.createPublicClient)({
+        chain: chainConfig,
+        transport: (0, import_viem.http)(rpcUrl)
+      });
+      console.log(`\u{1F50D} [getBalance] Checking balance for ${address} on ${chain}`);
+      const balanceWei = await client.getBalance({
+        address
+      });
+      const balance = (0, import_viem.formatEther)(balanceWei);
+      console.log(
+        `\u2705 [getBalance] Balance: ${balance} ${chainConfig.nativeCurrency.symbol}`
+      );
+      return {
+        success: true,
+        balance: `${balance} ${chainConfig.nativeCurrency.symbol}`,
+        balanceWei: balanceWei.toString(),
+        address,
+        chain
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("\u274C [getBalance] Error:", errorMessage);
+      return {
+        success: false,
+        balance: "0",
+        balanceWei: "0",
+        address: input.address,
+        chain: input.chain,
+        error: errorMessage
+      };
+    }
+  }
+});
+var getTransactionTool = createTool({
+  id: "getTransaction",
+  description: "Get transaction details by transaction hash",
+  inputSchema: import_zod.z.object({
+    hash: import_zod.z.string().describe("The transaction hash to look up"),
+    chain: import_zod.z.enum(["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]).default("mainnet").describe("The blockchain network to check on")
+  }),
+  outputSchema: import_zod.z.object({
+    success: import_zod.z.boolean(),
+    transaction: import_zod.z.object({
+      hash: import_zod.z.string(),
+      from: import_zod.z.string(),
+      to: import_zod.z.string().nullable(),
+      value: import_zod.z.string(),
+      gasUsed: import_zod.z.string().optional(),
+      gasPrice: import_zod.z.string().optional(),
+      blockNumber: import_zod.z.string().optional(),
+      status: import_zod.z.string().optional()
+    }).optional(),
+    error: import_zod.z.string().optional()
+  }),
+  execute: async ({ input, runtime }) => {
+    try {
+      const { hash, chain } = input;
+      const chainConfig = SUPPORTED_CHAINS[chain];
+      const rpcUrl = runtime.rpcUrl || chainConfig.rpcUrls.default.http[0];
+      const client = (0, import_viem.createPublicClient)({
+        chain: chainConfig,
+        transport: (0, import_viem.http)(rpcUrl)
+      });
+      console.log(
+        `\u{1F50D} [getTransaction] Looking up transaction ${hash} on ${chain}`
+      );
+      const transaction = await client.getTransaction({
+        hash
+      });
+      const receipt = await client.getTransactionReceipt({
+        hash
+      }).catch(() => null);
+      console.log(
+        `\u2705 [getTransaction] Found transaction from ${transaction.from} to ${transaction.to}`
+      );
+      return {
+        success: true,
+        transaction: {
+          hash: transaction.hash,
+          from: transaction.from,
+          to: transaction.to,
+          value: (0, import_viem.formatEther)(transaction.value),
+          gasUsed: receipt?.gasUsed.toString(),
+          gasPrice: transaction.gasPrice?.toString(),
+          blockNumber: transaction.blockNumber?.toString(),
+          status: receipt?.status === "success" ? "success" : receipt?.status === "reverted" ? "failed" : "pending"
+        }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("\u274C [getTransaction] Error:", errorMessage);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+});
+var sendTransactionTool = createTool({
+  id: "sendTransaction",
+  description: "Send native tokens to another address",
+  inputSchema: import_zod.z.object({
+    to: import_zod.z.string().describe("The recipient address"),
+    amount: import_zod.z.string().describe("The amount to send (in ETH, MATIC, etc.)"),
+    chain: import_zod.z.enum(["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]).default("mainnet").describe("The blockchain network to send on")
+  }),
+  outputSchema: import_zod.z.object({
+    success: import_zod.z.boolean(),
+    hash: import_zod.z.string().optional(),
+    from: import_zod.z.string().optional(),
+    to: import_zod.z.string(),
+    amount: import_zod.z.string(),
+    chain: import_zod.z.string(),
+    error: import_zod.z.string().optional()
+  }),
+  execute: async ({ input, runtime }) => {
+    try {
+      const { to, amount, chain } = input;
+      const chainConfig = SUPPORTED_CHAINS[chain];
+      const privateKey = runtime.privateKey;
+      if (!privateKey) {
+        return {
+          success: false,
+          to,
+          amount,
+          chain,
+          error: "Private key not configured in runtime"
+        };
+      }
+      const rpcUrl = runtime.rpcUrl || chainConfig.rpcUrls.default.http[0];
+      const account = (0, import_accounts.privateKeyToAccount)(privateKey);
+      const client = (0, import_viem.createWalletClient)({
+        account,
+        chain: chainConfig,
+        transport: (0, import_viem.http)(rpcUrl)
+      });
+      console.log(
+        `\u{1F4B8} [sendTransaction] Sending ${amount} ${chainConfig.nativeCurrency.symbol} to ${to} on ${chain}`
+      );
+      const hash = await client.sendTransaction({
+        to,
+        value: (0, import_viem.parseEther)(amount)
+      });
+      console.log(`\u2705 [sendTransaction] Transaction sent: ${hash}`);
+      return {
+        success: true,
+        hash,
+        from: account.address,
+        to,
+        amount,
+        chain
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("\u274C [sendTransaction] Error:", errorMessage);
+      return {
+        success: false,
+        to: input.to,
+        amount: input.amount,
+        chain: input.chain,
+        error: errorMessage
+      };
+    }
+  }
+});
+var getBlockTool = createTool({
+  id: "getBlock",
+  description: "Get information about a blockchain block",
+  inputSchema: import_zod.z.object({
+    blockNumber: import_zod.z.string().optional().describe("Block number (defaults to latest)"),
+    chain: import_zod.z.enum(["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]).default("mainnet").describe("The blockchain network to check on")
+  }),
+  outputSchema: import_zod.z.object({
+    success: import_zod.z.boolean(),
+    block: import_zod.z.object({
+      number: import_zod.z.string(),
+      hash: import_zod.z.string(),
+      timestamp: import_zod.z.string(),
+      transactionCount: import_zod.z.number(),
+      gasUsed: import_zod.z.string(),
+      gasLimit: import_zod.z.string()
+    }).optional(),
+    error: import_zod.z.string().optional()
+  }),
+  execute: async ({ input, runtime }) => {
+    try {
+      const { blockNumber, chain } = input;
+      const chainConfig = SUPPORTED_CHAINS[chain];
+      const rpcUrl = runtime.rpcUrl || chainConfig.rpcUrls.default.http[0];
+      const client = (0, import_viem.createPublicClient)({
+        chain: chainConfig,
+        transport: (0, import_viem.http)(rpcUrl)
+      });
+      console.log(
+        `\u{1F50D} [getBlock] Getting block ${blockNumber || "latest"} on ${chain}`
+      );
+      const block = await client.getBlock({
+        blockNumber: blockNumber ? BigInt(blockNumber) : void 0
+      });
+      console.log(
+        `\u2705 [getBlock] Found block ${block.number} with ${block.transactions.length} transactions`
+      );
+      return {
+        success: true,
+        block: {
+          number: block.number.toString(),
+          hash: block.hash,
+          timestamp: block.timestamp.toString(),
+          transactionCount: block.transactions.length,
+          gasUsed: block.gasUsed.toString(),
+          gasLimit: block.gasLimit.toString()
+        }
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("\u274C [getBlock] Error:", errorMessage);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+});
+var getGasPriceTool = createTool({
+  id: "getGasPrice",
+  description: "Get current gas price for a blockchain",
+  inputSchema: import_zod.z.object({
+    chain: import_zod.z.enum(["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]).default("mainnet").describe("The blockchain network to check on")
+  }),
+  outputSchema: import_zod.z.object({
+    success: import_zod.z.boolean(),
+    gasPrice: import_zod.z.string().optional().describe("Gas price in gwei"),
+    gasPriceWei: import_zod.z.string().optional().describe("Gas price in wei"),
+    chain: import_zod.z.string(),
+    error: import_zod.z.string().optional()
+  }),
+  execute: async ({ input, runtime }) => {
+    try {
+      const { chain } = input;
+      const chainConfig = SUPPORTED_CHAINS[chain];
+      const rpcUrl = runtime.rpcUrl || chainConfig.rpcUrls.default.http[0];
+      const client = (0, import_viem.createPublicClient)({
+        chain: chainConfig,
+        transport: (0, import_viem.http)(rpcUrl)
+      });
+      console.log(`\u26FD [getGasPrice] Getting gas price for ${chain}`);
+      const gasPrice = await client.getGasPrice();
+      const gasPriceGwei = (0, import_viem.formatEther)(gasPrice * BigInt(1e9));
+      console.log(`\u2705 [getGasPrice] Current gas price: ${gasPriceGwei} gwei`);
+      return {
+        success: true,
+        gasPrice: `${gasPriceGwei} gwei`,
+        gasPriceWei: gasPrice.toString(),
+        chain
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("\u274C [getGasPrice] Error:", errorMessage);
+      return {
+        success: false,
+        chain: input.chain,
+        error: errorMessage
+      };
+    }
+  }
+});
+var estimateGasTool = createTool({
+  id: "estimateGas",
+  description: "Estimate gas required for a transaction",
+  inputSchema: import_zod.z.object({
+    to: import_zod.z.string().describe("The recipient address"),
+    amount: import_zod.z.string().default("0").describe("The amount to send (defaults to 0)"),
+    data: import_zod.z.string().optional().describe("Transaction data (for contract calls)"),
+    chain: import_zod.z.enum(["mainnet", "sepolia", "polygon", "arbitrum", "optimism", "base"]).default("mainnet").describe("The blockchain network to estimate on")
+  }),
+  outputSchema: import_zod.z.object({
+    success: import_zod.z.boolean(),
+    gasEstimate: import_zod.z.string().optional(),
+    to: import_zod.z.string(),
+    amount: import_zod.z.string(),
+    chain: import_zod.z.string(),
+    error: import_zod.z.string().optional()
+  }),
+  execute: async ({ input, runtime }) => {
+    try {
+      const { to, amount, data, chain } = input;
+      const chainConfig = SUPPORTED_CHAINS[chain];
+      const privateKey = runtime.privateKey;
+      if (!privateKey) {
+        return {
+          success: false,
+          to,
+          amount,
+          chain,
+          error: "Private key not configured in runtime"
+        };
+      }
+      const rpcUrl = runtime.rpcUrl || chainConfig.rpcUrls.default.http[0];
+      const account = (0, import_accounts.privateKeyToAccount)(privateKey);
+      const client = (0, import_viem.createPublicClient)({
+        chain: chainConfig,
+        transport: (0, import_viem.http)(rpcUrl)
+      });
+      console.log(
+        `\u26FD [estimateGas] Estimating gas for transaction to ${to} on ${chain}`
+      );
+      const gasEstimate = await client.estimateGas({
+        account: account.address,
+        to,
+        value: (0, import_viem.parseEther)(amount),
+        data
+      });
+      console.log(`\u2705 [estimateGas] Estimated gas: ${gasEstimate.toString()}`);
+      return {
+        success: true,
+        gasEstimate: gasEstimate.toString(),
+        to,
+        amount,
+        chain
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("\u274C [estimateGas] Error:", errorMessage);
+      return {
+        success: false,
+        to: input.to,
+        amount: input.amount,
+        chain: input.chain,
+        error: errorMessage
+      };
+    }
+  }
+});
+var blockchainTools = {
+  getBalance: getBalanceTool,
+  getTransaction: getTransactionTool,
+  sendTransaction: sendTransactionTool,
+  getBlock: getBlockTool,
+  getGasPrice: getGasPriceTool,
+  estimateGas: estimateGasTool
+};
+
+// src/tools/xmtp.ts
+var import_zod2 = require("zod");
+var sendReactionTool = createTool({
+  id: "sendReaction",
+  description: "Send an emoji reaction to a message to indicate it has been seen",
+  inputSchema: import_zod2.z.object({
+    emoji: import_zod2.z.string().default("\u{1F440}").describe(
+      "The emoji to send as a reaction (supports common emoji like \u{1F44D}, \u2764\uFE0F, \u{1F525}, etc.)"
+    ),
+    referenceMessageId: import_zod2.z.string().optional().describe(
+      "The message ID to react to (uses current message if not provided)"
+    )
+  }),
+  outputSchema: import_zod2.z.object({
+    success: import_zod2.z.boolean(),
+    emoji: import_zod2.z.string(),
+    error: import_zod2.z.string().optional()
+  }),
+  execute: async ({ input, runtime }) => {
+    try {
+      const xmtpClient = runtime.xmtpClient;
+      const currentMessage = runtime.message;
+      if (!xmtpClient) {
+        const errorMsg = "\u274C XMTP service not available";
+        return { success: false, emoji: input.emoji, error: errorMsg };
+      }
+      if (!currentMessage) {
+        const errorMsg = "\u274C No message to react to";
+        return { success: false, emoji: input.emoji, error: errorMsg };
+      }
+      const messageIdToReactTo = input.referenceMessageId || currentMessage.id;
+      console.log(
+        `\u{1F440} [sendReaction] Sending ${input.emoji} reaction to message ${messageIdToReactTo}`
+      );
+      const reactionResult = await xmtpClient.sendReaction({
+        messageId: messageIdToReactTo,
+        emoji: input.emoji,
+        action: "added"
+      });
+      if (!reactionResult.success) {
+        const errorMsg = `\u274C Failed to send reaction: ${reactionResult.error || "Unknown error"}`;
+        return { success: false, emoji: input.emoji, error: errorMsg };
+      }
+      console.log(`\u2705 [sendReaction] Successfully sent ${input.emoji} reaction`);
+      return { success: true, emoji: input.emoji };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("\u274C [sendReaction] Error:", errorMessage);
+      return { success: false, emoji: input.emoji, error: errorMessage };
+    }
+  }
+});
+var sendMessageTool = createTool({
+  id: "sendMessage",
+  description: "Send a message to an XMTP conversation",
+  inputSchema: import_zod2.z.object({
+    content: import_zod2.z.string().describe("The message content to send"),
+    recipientAddress: import_zod2.z.string().optional().describe("Recipient address for new conversations"),
+    conversationId: import_zod2.z.string().optional().describe("Existing conversation ID to send to")
+  }).refine((data) => data.recipientAddress || data.conversationId, {
+    message: "Either recipientAddress or conversationId must be provided"
+  }),
+  outputSchema: import_zod2.z.object({
+    success: import_zod2.z.boolean(),
+    messageId: import_zod2.z.string().optional(),
+    conversationId: import_zod2.z.string().optional(),
+    content: import_zod2.z.string(),
+    error: import_zod2.z.string().optional()
+  }),
+  execute: async ({ input, runtime }) => {
+    try {
+      const xmtpClient = runtime.xmtpClient;
+      const { content, recipientAddress, conversationId } = input;
+      if (!xmtpClient) {
+        return {
+          success: false,
+          content,
+          error: "XMTP service not available"
+        };
+      }
+      console.log(
+        `\u{1F4AC} [sendMessage] Sending message: "${content.substring(0, 50)}${content.length > 50 ? "..." : ""}"`
+      );
+      let targetConversationId = conversationId;
+      if (!targetConversationId && recipientAddress) {
+        console.log(
+          `\u{1F50D} [sendMessage] Creating/finding conversation with ${recipientAddress}`
+        );
+        targetConversationId = recipientAddress;
+      }
+      const messageResult = await xmtpClient.sendMessage({
+        content
+      });
+      if (!messageResult.success) {
+        return {
+          success: false,
+          content,
+          error: messageResult.error || "Failed to send message"
+        };
+      }
+      console.log(`\u2705 [sendMessage] Message sent successfully`);
+      return {
+        success: true,
+        messageId: messageResult.data?.conversationId,
+        conversationId: messageResult.data?.conversationId,
+        content
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("\u274C [sendMessage] Error:", errorMessage);
+      return {
+        success: false,
+        content: input.content,
+        error: errorMessage
+      };
+    }
+  }
+});
+var sendReplyTool = createTool({
+  id: "sendReply",
+  description: "Send a reply to a specific message in an XMTP conversation",
+  inputSchema: import_zod2.z.object({
+    content: import_zod2.z.string().describe("The reply content to send"),
+    replyToMessageId: import_zod2.z.string().optional().describe("Message ID to reply to (uses current message if not provided)")
+  }),
+  outputSchema: import_zod2.z.object({
+    success: import_zod2.z.boolean(),
+    messageId: import_zod2.z.string().optional(),
+    replyToMessageId: import_zod2.z.string().optional(),
+    content: import_zod2.z.string(),
+    error: import_zod2.z.string().optional()
+  }),
+  execute: async ({ input, runtime }) => {
+    try {
+      const xmtpClient = runtime.xmtpClient;
+      const currentMessage = runtime.message;
+      const { content, replyToMessageId } = input;
+      if (!xmtpClient) {
+        return {
+          success: false,
+          content,
+          error: "XMTP service not available"
+        };
+      }
+      if (!currentMessage && !replyToMessageId) {
+        return {
+          success: false,
+          content,
+          error: "No message to reply to"
+        };
+      }
+      const targetMessageId = replyToMessageId || currentMessage?.id;
+      console.log(
+        `\u21A9\uFE0F [sendReply] Sending reply to message ${targetMessageId}: "${content.substring(0, 50)}${content.length > 50 ? "..." : ""}"`
+      );
+      const replyResult = await xmtpClient.sendReply({
+        content,
+        messageId: targetMessageId
+      });
+      if (!replyResult.success) {
+        return {
+          success: false,
+          content,
+          replyToMessageId: targetMessageId,
+          error: replyResult.error || "Failed to send reply"
+        };
+      }
+      console.log(`\u2705 [sendReply] Reply sent successfully`);
+      return {
+        success: true,
+        messageId: replyResult.data?.conversationId,
+        replyToMessageId: targetMessageId,
+        content
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("\u274C [sendReply] Error:", errorMessage);
+      return {
+        success: false,
+        content: input.content,
+        replyToMessageId: input.replyToMessageId,
+        error: errorMessage
+      };
+    }
+  }
+});
+var getMessageTool = createTool({
+  id: "getMessage",
+  description: "Get a specific message by ID from XMTP",
+  inputSchema: import_zod2.z.object({
+    messageId: import_zod2.z.string().describe("The message ID to retrieve")
+  }),
+  outputSchema: import_zod2.z.object({
+    success: import_zod2.z.boolean(),
+    message: import_zod2.z.object({
+      id: import_zod2.z.string(),
+      conversationId: import_zod2.z.string(),
+      content: import_zod2.z.union([import_zod2.z.string(), import_zod2.z.record(import_zod2.z.unknown())]),
+      senderInboxId: import_zod2.z.string(),
+      sentAt: import_zod2.z.string(),
+      contentType: import_zod2.z.object({
+        typeId: import_zod2.z.string(),
+        authorityId: import_zod2.z.string().optional(),
+        versionMajor: import_zod2.z.number().optional(),
+        versionMinor: import_zod2.z.number().optional()
+      }).optional()
+    }).optional(),
+    error: import_zod2.z.string().optional()
+  }),
+  execute: async ({ input, runtime }) => {
+    try {
+      const xmtpClient = runtime.xmtpClient;
+      const { messageId } = input;
+      if (!xmtpClient) {
+        return {
+          success: false,
+          error: "XMTP service not available"
+        };
+      }
+      console.log(`\u{1F4DC} [getMessage] Retrieving message ${messageId}`);
+      const messageResult = await xmtpClient.getMessage({
+        messageId
+      });
+      if (!messageResult.success) {
+        return {
+          success: false,
+          error: messageResult.error || "Failed to get message"
+        };
+      }
+      console.log(
+        `\u2705 [getMessage] Retrieved message from ${messageResult.data?.senderInboxId}`
+      );
+      return {
+        success: true,
+        message: messageResult.data
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      console.error("\u274C [getMessage] Error:", errorMessage);
+      return {
+        success: false,
+        error: errorMessage
+      };
+    }
+  }
+});
+var xmtpTools = {
+  sendMessage: sendMessageTool,
+  sendReply: sendReplyTool,
+  sendReaction: sendReactionTool,
+  getMessage: getMessageTool
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  blockchainTools,
+  estimateGasTool,
+  getBalanceTool,
+  getBlockTool,
+  getGasPriceTool,
+  getMessageTool,
+  getTransactionTool,
+  sendMessageTool,
+  sendReactionTool,
+  sendReplyTool,
+  sendTransactionTool,
+  xmtpTools
+});
+//# sourceMappingURL=index.cjs.map