XMTP Agent Examples

https://github.com/xmtplabs/xmtp-agent-examples
Admin
A collection of runnable example agents demonstrating various capabilities of the XMTP Agent SDK,...
Tokens:34,123
Snippets:366
Trust Score:9.6
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Dependencies for Example

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/CONTRIBUTING.md

Navigate to your example's directory and install necessary packages using Yarn.

```bash
cd examples/your-example
yarn
```

--------------------------------

### Clone, Install, and Run XMTP Smart Wallet Example

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-smart-wallet/README.md

Follow these commands to clone the repository, navigate to the example directory, install dependencies, and run the agent. Optional key generation is available.

```bash
# git clone repo
git clone https://github.com/ephemeraHQ/xmtp-agent-examples.git
# go to the folder
cd xmtp-agent-examples
cd examples/xmtp-smart-wallet
# install packages
yarn
# generate random xmtp keys (optional)
yarn gen:keys
# run the example
yarn dev
```

--------------------------------

### Running the XMTP Gaia Agent

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-gaia/README.md

Follow these steps to set up and run the XMTP Gaia agent example. This includes cloning the repository, installing dependencies, and starting the agent.

```bash
# git clone repo
git clone https://github.com/ephemeraHQ/xmtp-agent-examples.git
# go to the folder
cd xmtp-agent-examples
cd examples/xmtp-gaia
# install packages
yarn
# generate random xmtp keys (optional)
yarn gen:keys
# run the example
yarn dev
```

--------------------------------

### Running the XMTP Agent Example

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-queue-dual-client/README.md

Follow these steps to clone the repository, install dependencies, and run the dual client queue example.

```bash
# Clone the repository
git clone https://github.com/ephemeraHQ/xmtp-agent-examples.git
# Navigate to the queue dual client example directory
cd xmtp-agent-examples/examples/xmtp-queue-dual-client
# Install dependencies
yarn
# Generate random XMTP keys (optional)
yarn gen:keys
# Run the example
yarn dev
```

--------------------------------

### Running the XMTP Welcome Message Example

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-welcome-message/README.md

Commands to clone the repository, install dependencies, generate keys, and run the XMTP welcome message example agent.

```bash
# git clone repo
git clone https://github.com/ephemeraHQ/xmtp-agent-examples.git
# go to the folder
cd xmtp-agent-examples
cd examples/xmtp-welcome-message
# install packages
yarn
# generate random xmtp keys (optional)
yarn gen:keys
# run the example
yarn dev
```

--------------------------------

### Running the XMTP Transactions Example

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-transactions/README.md

Steps to clone the repository, install dependencies, and run the XMTP transactions example locally.

```bash
# git clone repo
git clone https://github.com/ephemeraHQ/xmtp-agent-examples.git
# go to the folder
cd xmtp-agent-examples
cd examples/xmtp-transactions
# install packages
yarn
# generate random xmtp keys (optional)
yarn gen:keys
# run the example
yarn dev
```

--------------------------------

### Running the XMTP GPT Agent Example

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-gpt/README.md

Follow these steps to clone the repository, navigate to the example directory, install dependencies, and run the agent. Optional: generate XMTP keys if needed.

```bash
# git clone repo
git clone https://github.com/ephemeraHQ/xmtp-agent-examples.git
# go to the folder
cd xmtp-agent-examples
cd examples/xmtp-gpt
# install packages
yarn
# generate random xmtp keys (optional)
yarn gen:keys
# run the example
yarn dev
```

--------------------------------

### Quick Start: XMTP Transaction Helpers

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/handling-transactions/SKILL.md

Initialize XMTP transaction helpers using viem chains and bigint amounts. This example demonstrates getting token decimals, checking balances, and creating USDC transfer calls.

```typescript
import {
  createERC20TransferCalls,
  getERC20Balance,
  getERC20Decimals,
  validHex,
} from "@xmtp/agent-sdk";
import { formatUnits, parseUnits } from "viem";
import { base, baseSepolia } from "viem/chains";

const CHAIN = baseSepolia; // or base for mainnet
const USDC_ADDRESS = "0x036CbD53842c5426634e7929541eC2318f3dCF7e"; // Base Sepolia

// Get decimals (e.g. 6 for USDC)
const decimals = await getERC20Decimals({ chain: CHAIN, tokenAddress: USDC_ADDRESS });

// Check balance (returns bigint; format for display)
const balance = await getERC20Balance({
  chain: CHAIN,
  tokenAddress: USDC_ADDRESS,
  address: validHex(address),
});
await ctx.conversation.sendText(`Your balance: ${formatUnits(balance, decimals)} USDC`);

// Create USDC transfer calls (EIP-5792)
const calls = createERC20TransferCalls({
  chain: CHAIN,
  tokenAddress: USDC_ADDRESS,
  from: validHex(fromAddress),
  to: validHex(toAddress),
  amount: parseUnits("1", decimals), // 1 USDC
  description: `Transfer 1 USDC on ${CHAIN.name}`,
});
await ctx.conversation.sendWalletSendCalls(calls);
```

--------------------------------

### Clone and Run XMTP Agent Example

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/README.md

Clone the repository, install dependencies, generate XMTP keys, and run a specific example agent like 'xmtp-gm'.

```bash
git clone https://github.com/xmtplabs/xmtp-agent-examples.git
cd xmtp-agent-examples

yarn

yarn gen:keys

cd examples/xmtp-gm
yarn dev
```

--------------------------------

### Run XMTP Agent Example

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-domain-resolver/README.md

Provides a sequence of shell commands to clone the repository, navigate to the example directory, install dependencies, generate keys, and run the XMTP domain resolver agent.

```bash
# git clone repo
git clone https://github.com/ephemeraHQ/xmtp-agent-examples.git
# go to the folder
cd xmtp-agent-examples
cd examples/xmtp-domain-resolver
# install packages
yarn
# generate random xmtp keys (optional)
yarn gen:keys
# run the example
yarn dev
```

--------------------------------

### Run Example Development Server

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/CONTRIBUTING.md

Execute the example locally to test your changes during development.

```bash
yarn dev
```

--------------------------------

### Run the XMTP Thinking Reaction Agent

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-thinking-reaction/README.md

Follow these commands to clone the repository, navigate to the example directory, install dependencies, and run the agent.

```bash
# git clone repo
git clone https://github.com/ephemeraHQ/xmtp-agent-examples.git
# go to the folder
cd xmtp-agent-examples
cd examples/xmtp-thinking-reaction
# install packages
yarn
# generate random xmtp keys (optional)
yarn gen:keys
# run the example
yarn dev
```

--------------------------------

### Example package.json template

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/AGENTS.md

A template for the package.json file used in example agents, including scripts for building, development, key generation, and starting the agent.

```json
{
  "name": "@examples/xmtp-agent-name",
  "version": "0.0.1",
  "private": true,
  "type": "module",
  "scripts": {
    "build": "tsc",
    "dev": "tsx --watch index.ts",
    "gen:keys": "yarn dlx @xmtp/cli init --output ./.env",
    "start": "tsx index.ts"
  },
  "dependencies": {
    "@xmtp/agent-sdk": "*"
  },
  "devDependencies": {
    "tsx": "*",
    "typescript": "*"
  },
  "engines": {
    "node": ">=20"
  }
}
```

--------------------------------

### Run the XMTP Gated Group Agent

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-gated-group/README.md

Provides the command-line instructions to clone the repository, install dependencies, generate keys (optional), and run the gated group example agent.

```bash
# git clone repo
git clone https://github.com/ephemeraHQ/xmtp-agent-examples.git
# go to the folder
cd xmtp-agent-examples
cd examples/xmtp-gated-group
# install packages
yarn
# generate random xmtp keys (optional)
yarn gen:keys
# run the example
yarn dev
```

--------------------------------

### Running the XMTP GM Agent

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-gm/README.md

Clone the repository, navigate to the example directory, install dependencies, generate keys if needed, and run the agent using yarn.

```bash
# git clone repo
git clone https://github.com/ephemeraHQ/xmtp-agent-examples.git
# go to the folder
cd xmtp-agent-examples
cd examples/xmtp-gm
# install packages
yarn
# generate random xmtp keys (optional)
yarn gen:keys
# run the example
yarn dev
```

--------------------------------

### Environment Variables Setup

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-generalstore/README.md

Configure necessary environment variables by creating a .env file. Ensure XMTP_WALLET_KEY, XMTP_DB_ENCRYPTION_KEY, and XMTP_ENV are set.

```bash
XMTP_WALLET_KEY=your_private_key_here
XMTP_DB_ENCRYPTION_KEY=your_encryption_key_here
XMTP_ENV=dev
```

--------------------------------

### Create New Branch for Example

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/CONTRIBUTING.md

Create a new branch for your specific example to keep changes organized.

```bash
git checkout -b example/your-example-name
```

--------------------------------

### Environment Variables Setup

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-queue-dual-client/README.md

Configure your XMTP agent by creating a .env file with the necessary credentials and settings.

```bash
XMTP_WALLET_KEY= # the private key of the wallet
XMTP_DB_ENCRYPTION_KEY= # encryption key for the local database
XMTP_ENV=dev # local, dev, production
```

--------------------------------

### Agent Initialization and Event Handling

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/AGENTS.md

Demonstrates how to initialize an agent from environment variables, listen for 'text' messages, and log agent and test network information on 'start'.

```typescript
import { Agent, getTestUrl } from "@xmtp/agent-sdk";

const agent = await Agent.createFromEnv();

agent.on("text", async (ctx) => {
  await ctx.conversation.sendText("Hello!");
});

agent.on("start", () => {
  console.log(`Agent: ${agent.address}`);
  console.log(`Test: ${getTestUrl(agent.client)}`);
});

await agent.start();
```

--------------------------------

### Quick Start: XMTP Agent with Inline Actions

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/creating-inline-actions/SKILL.md

This snippet shows the basic setup for enabling inline actions in an XMTP agent. It includes adding middleware, registering an action handler, and sending interactive buttons.

```typescript
// 1. Add middleware to handle intent messages
agent.use(inlineActionsMiddleware);

// 2. Register action handlers
registerAction("my-action", async (ctx) => {
  await ctx.conversation.sendText("Action executed!");
});

// 3. Send interactive buttons
await ActionBuilder.create("my-menu", "Choose an option:")
  .add("my-action", "Click Me")
  .add("other-action", "Cancel")
  .send(ctx);
```

--------------------------------

### Handle Agent Start Event

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/building-agents/rules/events-lifecycle.md

Use the 'start' event to run code when the agent initializes. This includes accessing the agent's address and client for further operations. Ensure the agent is started with `await agent.start()`.

```typescript
import { getTestUrl } from "@xmtpl/agent-sdk";

agent.on("start", () => {
  console.log(`Agent address: ${agent.address}`);
  console.log(`Test URL: ${getTestUrl(agent.client)}`);
  console.log("Agent started. Waiting for messages...");
});

await agent.start();
```

--------------------------------

### Start and Stop Local XMTP Network

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/README.md

Manage a local XMTP network by starting it with './dev/up' and stopping it with './dev/down'. Remember to update your .env file to use the local environment.

```bash
# Start local network
./dev/up

# Update .env
XMTP_ENV=local

# Stop
./dev/down
```

--------------------------------

### Install XMTP Agent SDK

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/building-agents/SKILL.md

Install the XMTP Agent SDK using npm or yarn. SDK 2.0+ uses unified exports.

```bash
npm install @xmtp/agent-sdk
# or
yarn add @xmtp/agent-sdk
```

--------------------------------

### Running the General Store Bot

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-generalstore/README.md

Steps to install dependencies, generate keys, and run the XMTP General Store Bot agent. Interact by sending 'hi' or 'menu'.

```bash
cd examples/xmtp-generalstore
yarn install
yarn gen:keys
yarn dev
```

--------------------------------

### Clone XMTP Agent Examples Repository

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/CONTRIBUTING.md

Clone the forked repository to your local machine to begin making changes.

```bash
git clone https://github.com/your-username/xmtp-agent-examples.git
cd xmtp-agent-examples
```

--------------------------------

### Quick Start XMTP Agent

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/building-agents/SKILL.md

Create an agent using environment variables, handle text messages, and log when the agent is online. Ensure environment variables are set before running.

```typescript
import { Agent, getTestUrl } from "@xmtp/agent-sdk";

// Create agent using environment variables
const agent = await Agent.createFromEnv();

// Handle text messages
agent.on("text", async (ctx) => {
  await ctx.conversation.sendText("Hello from my XMTP Agent!");
});

// Log when ready
agent.on("start", () => {
  console.log(`Agent online: ${getTestUrl(agent.client)}`);
});

await agent.start();
```

--------------------------------

### Environment Setup for XMTP Agents

Source: https://context7.com/xmtplabs/xmtp-agent-examples/llms.txt

Configure required environment variables before running any agent. Keys can be generated with `yarn gen:keys`.

```bash
# .env
XMTP_ENV=dev                          # local | dev | production
XMTP_WALLET_KEY=0x1234...abcd         # Private key for the agent wallet
XMTP_DB_ENCRYPTION_KEY=0xabcd...1234  # Encryption key for local MLS database

# Optional
XMTP_DB_DIRECTORY=./data              # Custom database directory
XMTP_FORCE_DEBUG_LEVEL=Debug          # Debug | Info | Warn | Error
```

```bash
# Generate fresh keys and append to .env
yarn gen:keys

# Install dependencies
yarn

# Run an example
cd examples/xmtp-gm && yarn dev
```

--------------------------------

### AI-Assisted Development Prompt

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/README.md

Use prompts to guide AI in creating agents, such as an agent that multiplies numbers by 2.

```bash
Prompt: Create an agent that multiplies numbers by 2
```

--------------------------------

### Environment Variables Setup

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-gpt/README.md

Configure these environment variables in a .env file to run your XMTP agent. Ensure you have your XMTP wallet key, a database encryption key, the XMTP environment, and your OpenAI API key.

```bash
XMTP_WALLET_KEY= # the private key of the wallet
XMTP_DB_ENCRYPTION_KEY= # encryption key for the local database
XMTP_ENV=dev # local, dev, production
OPENAI_API_KEY= # the API key for the OpenAI API
```

--------------------------------

### Environment Variable Setup

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/resolving-domains/rules/resolve-address.md

Set the `WEB3_BIO_API_KEY` environment variable to optionally increase API rate limits when using the name resolver.

```bash
WEB3_BIO_API_KEY=your_api_key  # Optional, for higher rate limits
```

--------------------------------

### Save downloaded attachment to disk

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/handling-attachments/rules/receive-attachment.md

This example demonstrates how to download an attachment and save its content to a local file. It also sends a confirmation message back to the sender. Requires the `fs` module and `@xmtp/agent-sdk`.

```typescript
import fs from "fs";
import { downloadRemoteAttachment } from "@xmtp/agent-sdk";

agent.on("attachment", async (ctx) => {
  const attachment = await downloadRemoteAttachment(ctx.message.content);

  fs.writeFileSync(`./downloads/${attachment.filename}`, attachment.content);
  await ctx.conversation.sendText(`Saved: ${attachment.filename}`);
});

```

--------------------------------

### Fetch Farcaster Profile in Agent Context

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/resolving-domains/rules/profiles-farcaster.md

Integrate `fetchFarcasterProfile` within an agent's event handler to greet users with their Farcaster profile information. This example shows how to get the sender's address and use it to fetch their profile.

```typescript
agent.on("text", async (ctx) => {
  const senderAddress = await ctx.getSenderAddress();
  const profile = await fetchFarcasterProfile(senderAddress);
  
  if (profile.username) {
    await ctx.conversation.sendText(
      `Hello ${profile.displayName || profile.username}! ` +
      `You have ${profile.social?.follower || 0} followers on Farcaster.`
    );
  }
});
```

--------------------------------

### Example usage of message type filters

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/handling-commands/rules/filters-message-types.md

This example demonstrates how to combine `filter.hasDefinedContent`, `filter.fromSelf`, and `isText` to process valid text messages within an agent's message handler.

```typescript
import { filter, isText } from "@xmtp/agent-sdk";

agent.on("message", async (ctx) => {
  if (
    filter.hasDefinedContent(ctx.message) &&
    !filter.fromSelf(ctx.message, ctx.client) &&
    isText(ctx.message)
  ) {
    await ctx.conversation.sendText("Valid text message received");
  }
});
```

--------------------------------

### Send Welcome Message with Inline Actions

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/managing-groups/rules/welcome-on-install.md

Enhance your welcome message by including interactive inline actions. This example uses ActionBuilder to add buttons for common user requests.

```typescript
async function sendWelcomeMessage(ctx: ConversationContext) {
  const welcomeActions = ActionBuilder.create(
    `welcome-${Date.now()}`,
    "👋 Welcome! I'm your ETH price agent. What would you like to do?"
  )
    .add("get-current-price", "💰 Get Current ETH Price")
    .add("get-price-chart", "📊 Get Price with 24h Change")
    .build();

  await ctx.conversation.sendActions(welcomeActions);
}
```

--------------------------------

### USDC Balance Check in Command Handler

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/handling-transactions/rules/balance-check.md

Integrate USDC balance checking into a command handler using `CommandRouter`. This example fetches both the agent's and the sender's balances concurrently using `Promise.all`.

```typescript
import {
  CommandRouter,
  getERC20Balance,
  getERC20Decimals,
  validHex,
} from "@xmtp/agent-sdk";
import { formatUnits } from "viem";

const router = new CommandRouter();

router.command("/balance", async (ctx) => {
  const agentAddress = agent.address;
  const senderAddress = await ctx.getSenderAddress();
  const decimals = await getERC20Decimals({ chain: CHAIN, tokenAddress: USDC_ADDRESS });

  const [agentBalance, senderBalance] = await Promise.all([
    getERC20Balance({ chain: CHAIN, tokenAddress: USDC_ADDRESS, address: validHex(agentAddress) }),
    getERC20Balance({ chain: CHAIN, tokenAddress: USDC_ADDRESS, address: validHex(senderAddress) }),
  ]);

  await ctx.conversation.sendText(
    `Agent balance: ${formatUnits(agentBalance, decimals)} USDC\n` +
      `Your balance: ${formatUnits(senderBalance, decimals)} USDC`,
  );
});
```

--------------------------------

### Common Reaction Patterns

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/sending-reactions/rules/send-reaction.md

Provides examples of using `sendReaction` for common use cases like acknowledging receipt, showing processing, or indicating an error.

```APIDOC
## Common Reaction Patterns

### Description
Illustrates using `sendReaction` for various communication signals.

#### Acknowledge Receipt
```typescript
await ctx.conversation.sendReaction({
  reference: ctx.message.id,
  action: "added",
  content: "✅",
  schema: "unicode"
});
```

#### Show Processing
```typescript
await ctx.conversation.sendReaction({
  reference: ctx.message.id,
  action: "added",
  content: "⏳",
  schema: "unicode"
});
```

#### Show Error
```typescript
await ctx.conversation.sendReaction({
  reference: ctx.message.id,
  action: "added",
  content: "❌",
  schema: "unicode"
});
```
```

--------------------------------

### Get ERC-20 Balance with XMTP SDK

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/handling-transactions/SKILL.md

Retrieves the ERC-20 token balance for a given address using the XMTP SDK and formats it using viem's formatUnits. Requires the token's decimals.

```typescript
import { getERC20Balance, getERC20Decimals } from "@xmtp/agent-sdk";
import { formatUnits } from "viem";

const balance = await getERC20Balance({
  chain: CHAIN,
  tokenAddress: USDC_ADDRESS,
  address: validHex(address),
});
const decimals = await getERC20Decimals({ chain: CHAIN, tokenAddress: USDC_ADDRESS });
const formatted = formatUnits(balance, decimals);
```

--------------------------------

### Agent Middleware Pipeline

Source: https://context7.com/xmtplabs/xmtp-agent-examples/llms.txt

Intercepts messages before event handlers. Use `await next()` to continue, return early to stop, or throw to trigger error middleware. Setup requires importing Agent, AgentMiddleware, and AgentErrorMiddleware.

```typescript
import { Agent, AgentMiddleware, AgentErrorMiddleware, isText, filter } from "@xmtpl/agent-sdk";

const agent = await Agent.createFromEnv();

// Filter: only pass text messages that are not from the agent itself
const textOnly: AgentMiddleware = async (ctx, next) => {
  if (isText(ctx.message) && !filter.fromSelf(ctx.message, ctx.client)) {
    await next();
  }
  // Implicit return — drops other message types
};

// Logging middleware
const logger: AgentMiddleware = async (ctx, next) => {
  console.log(`[${new Date().toISOString()}] Received: ${ctx.message.contentType?.typeId}`);
  await next();
};

// Error handling middleware
const errorHandler: AgentErrorMiddleware = async (error, ctx, next) => {
  console.error("Middleware error:", error instanceof Error ? error.message : error);
  await ctx.conversation.sendText("Something went wrong, please try again.");
  await next(error); // pass error up the chain
};

agent.use([logger, textOnly]);
agent.errors.use(errorHandler);

agent.on("text", async (ctx) => {
  await ctx.conversation.sendText(`Echo: ${ctx.message.content}`);
});

await agent.start();
```

--------------------------------

### Message Filters and Type Guards

Source: https://context7.com/xmtplabs/xmtp-agent-examples/llms.txt

Use direct imports like `isText`, `isReaction` for type-safe filtering. `ctx.usesCodec()` checks runtime codec compatibility. Setup requires importing Agent and filter/type guard functions.

```typescript
import {
  Agent,
  filter,
  isReaction,
  isRemoteAttachment,
  isReply,
  isText,
} from "@xmtpl/agent-sdk";
import { TransactionReferenceCodec } from "@xmtpl/content-type-transaction-reference";

const agent = await Agent.createFromEnv();

// Generic message handler with type guards
agent.on("message", async (ctx) => {
  // Skip own messages and empty content
  if (filter.fromSelf(ctx.message, ctx.client)) return;
  if (!filter.hasDefinedContent(ctx.message)) return;

  if (isText(ctx.message)) {
    console.log("Text:", ctx.message.content);
  } else if (isReaction(ctx.message)) {
    console.log("Reaction:", ctx.message.content.content);
  } else if (isReply(ctx.message)) {
    console.log("Reply to:", ctx.message.content.reference);
  } else if (isRemoteAttachment(ctx.message)) {
    console.log("Attachment URL:", ctx.message.content.url);
  }

  // Codec-based type guard narrows content type safely
  if (ctx.usesCodec(TransactionReferenceCodec)) {
    const ref = ctx.message.content; // TypeScript knows this is TransactionReference
    console.log("Tx hash:", ref.reference, "Network:", ref.networkId);
  }
});

await agent.start();
```

--------------------------------

### Set Up Environment Variables

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-gated-group/README.md

Lists the required environment variables for running the XMTP agent, including wallet keys, database encryption keys, XMTP environment, and Gaia API details.

```bash
XMTP_WALLET_KEY= # the private key of the wallet
XMTP_DB_ENCRYPTION_KEY= # a second random 32 bytes encryption key for local db encryption
XMTP_ENV=dev # local, dev, production
GAIA_API_KEY= # Your API key from https://gaianet.ai
GAIA_NODE_URL= # Your custom Gaia node URL or a public node, ex: https://llama8b.gaia.domains/v1
GAIA_MODEL_NAME= # Model name running in your Gaia node or a public node, ex: llama
```

--------------------------------

### Get group member details

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/managing-groups/rules/members-add.md

Retrieve all members of a conversation and iterate through them to access details like inbox ID, permission level, Ethereum address, and installation IDs. The Ethereum address can be found by filtering `accountIdentifiers`.

```typescript
const members = await conversation.members();

for (const member of members) {
  console.log("Inbox ID:", member.inboxId);
  console.log("Permission:", member.permissionLevel);
  
  // Get Ethereum address
  const ethId = member.accountIdentifiers.find(
    (id) => id.identifierKind === IdentifierKind.Ethereum
  );
  if (ethId) {
    console.log("Address:", ethId.identifier);
  }
  
  // Get installation IDs
  console.log("Installations:", member.installationIds);
}
```

--------------------------------

### Revoke XMTP Agent Installations

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/README.md

Revoke specific installations for an XMTP agent using its inbox ID and a list of installations to exclude.

```bash
yarn revoke <inbox-id> <installations-to-exclude>
```

--------------------------------

### Initialize XMTP Agent with Agent.createFromEnv

Source: https://context7.com/xmtplabs/xmtp-agent-examples/llms.txt

Creates an XMTP agent by reading all configuration from environment variables. This is the canonical way to initialize an agent; avoid manual signer construction.

```typescript
import { Agent, getTestUrl } from "@xmtp/agent-sdk";

// Load .env file
process.loadEnvFile(".env");

// Create agent — reads XMTP_WALLET_KEY, XMTP_DB_ENCRYPTION_KEY, XMTP_ENV automatically
const agent = await Agent.createFromEnv();

agent.on("start", () => {
  console.log(`Agent address: ${agent.address}`);
  console.log(`Test at: ${getTestUrl(agent.client)}`);
});

await agent.start();
// Output: Agent address: 0xabc...
// Output: Test at: https://xmtp.chat/dm/0xabc...
```

--------------------------------

### Configure XMTP Environment Variables

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/README.md

Set up essential environment variables for XMTP agent development, including wallet private key, database encryption key, and XMTP environment.

```bash
XMTP_WALLET_KEY=      # Private key for the wallet
XMTP_DB_ENCRYPTION_KEY= # Encryption key for local database
XMTP_ENV=dev          # local, dev, or production
```

--------------------------------

### Agent Creation Using Environment Variables (Correct)

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/building-agents/rules/setup-from-env.md

Use `Agent.createFromEnv()` for automatic configuration loading. Ensure your .env file is loaded if using local environment variables.

```typescript
import { Agent } from "@xmtp/agent-sdk";

// Load .env file
process.loadEnvFile(".env");

// Create agent using environment variables
const agent = await Agent.createFromEnv();
```

--------------------------------

### Get Group Member Details

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/managing-groups/rules/members-add.md

Retrieves details for all members of a group, including their inbox ID, permission level, and account identifiers.

```APIDOC
## Get Member Details

### Description
Retrieves a list of members in the group along with their details.

### Method
`conversation.members()`

### Response
#### Success Response
- **members** (Array<MemberDetails>) - An array of member objects, where each object contains:
  - **inboxId** (string) - The inbox ID of the member.
  - **permissionLevel** (PermissionLevel) - The permission level of the member.
  - **accountIdentifiers** (Array<AccountIdentifier>) - An array of account identifiers for the member.

### Response Example
```typescript
const members = await conversation.members();

for (const member of members) {
  console.log("Inbox ID:", member.inboxId);
  console.log("Permission:", member.permissionLevel);
  
  // Get Ethereum address
  const ethId = member.accountIdentifiers.find(
    (id) => id.identifierKind === IdentifierKind.Ethereum
  );
  if (ethId) {
    console.log("Address:", ethId.identifier);
  }
  
  // Get installation IDs
  console.log("Installations:", member.installationIds);
}
```
```

--------------------------------

### Define App Configuration with Multiple Menus

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/creating-inline-actions/rules/config-menus.md

Use AppConfig to define the structure of your bot's menus, including nested menus and actions. Initialize the app with this configuration.

```typescript
import { AppConfig, initializeAppFromConfig, showMenu } from "../../utils/inline-actions";

const config: AppConfig = {
  name: "My Bot",
  menus: {
    "main-menu": {
      id: "main-menu",
      title: "Main Menu",
      actions: [
        { id: "products-menu", label: "🛍️ Browse Products" },
        { id: "cart-menu", label: "🛒 View Cart" },
        { id: "help", label: "❓ Help", handler: helpHandler },
      ],
    },
    "products-menu": {
      id: "products-menu",
      title: "Products",
      actions: [
        { id: "buy-item-1", label: "Item 1 - $10", handler: buyItem1 },
        { id: "buy-item-2", label: "Item 2 - $20", handler: buyItem2 },
        { id: "main-menu", label: "⬅️ Back" },
      ],
    },
  },
  options: {
    autoShowMenuAfterAction: true,
    defaultNavigationMessage: "What would you like to do next?",
  },
};

// Initialize the app
initializeAppFromConfig(config);
```

--------------------------------

### Create and Export Smart Contract Wallet

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-smart-wallet/README.md

Use the Coinbase SDK to configure credentials, create a wallet, and export its data. Ensure CDP_API_KEY_NAME and CDP_API_KEY_PRIVATE_KEY are set in your environment.

```typescript
Coinbase.configure({
  apiKeyName: CDP_API_KEY_NAME,
  privateKey: CDP_API_KEY_PRIVATE_KEY,
});
const wallet = await Wallet.create({
  networkId: NETWORK_ID,
});

console.log("Wallet created successfully, exporting data...");
const data = wallet.export();
console.log("Getting default address...");
const walletInfo: WalletData = {
  seed: data.seed || "",
  walletId: wallet.getId() || "",
  networkId: wallet.getNetworkId(),
};
```

--------------------------------

### Create a basic action menu

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/creating-inline-actions/rules/builder-create.md

Use ActionBuilder to create a simple menu with default button styles. Ensure the menu ID and context are correctly provided.

```typescript
import { ActionBuilder } from "../../utils/inline-actions";

await ActionBuilder.create("menu-id", "Choose an option:")
  .add("action-1", "Option 1")
  .add("action-2", "Option 2")
  .add("action-3", "Cancel")
  .send(ctx);
```

--------------------------------

### Generate XMTP Keys

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/building-agents/rules/setup-environment.md

Use this command to generate the necessary private keys for your XMTP agent. Warning: Running this command will append keys to your existing .env file.

```bash
yarn gen:keys
```

--------------------------------

### Group Gating with Secret Passphrase

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/managing-groups/rules/welcome-on-install.md

Implement a group gating mechanism where users must provide a secret passphrase to be added to a group. This example listens for 'dm' to prompt for the passphrase and 'text' to validate it.

```typescript
import { IdentifierKind } from "@xmtp/agent-sdk";

const GROUP_CONFIG = {
  secretWord: "xmtp",
  groupName: "Secret Group",
  messages: {
    welcome: "Hi! What's the secret passphrase?",
    success: "🎉 Correct! You've been added to the group.",
    invalid: "❌ Invalid passphrase. Please try again.",
  },
};

agent.on("dm", async (ctx) => {
  await ctx.conversation.sendText(GROUP_CONFIG.messages.welcome);
});

agent.on("text", async (ctx) => {
  if (ctx.message.content.toLowerCase() === GROUP_CONFIG.secretWord) {
    const senderAddress = await ctx.getSenderAddress();
    await group.addMembersByIdentifiers([{ 
      identifier: senderAddress,
      identifierKind: IdentifierKind.Ethereum,
    }]);
    await ctx.conversation.sendText(GROUP_CONFIG.messages.success);
  } else {
    await ctx.conversation.sendText(GROUP_CONFIG.messages.invalid);
  }
});
```

--------------------------------

### Set Required XMTP Environment Variables

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/building-agents/rules/setup-environment.md

Configure the essential environment variables for your XMTP agent. Ensure XMTP_ENV is set to 'dev', 'local', or 'production'. Generate XMTP_WALLET_KEY and XMTP_DB_ENCRYPTION_KEY using the provided command.

```bash
# Network: local, dev, or production
XMTP_ENV=dev

# Private keys (generate with yarn gen:keys)
XMTP_WALLET_KEY=0x1234...abcd
XMTP_DB_ENCRYPTION_KEY=0xabcd...1234
```

--------------------------------

### Send Selection Menu with Custom Styles

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/creating-inline-actions/rules/helpers-selection.md

Customize the appearance of selection options using the `ActionStyle` enum. For example, `ActionStyle.Danger` can be used to visually distinguish destructive actions. Import both `sendSelection` and `ActionStyle`.

```typescript
import { sendSelection, ActionStyle } from "../../utils/inline-actions";

await sendSelection(ctx, "Choose action:", [
  {
    id: "save",
    label: "💾 Save",
    handler: saveHandler,
  },
  {
    id: "delete",
    label: "🗑️ Delete",
    style: ActionStyle.Danger,
    handler: deleteHandler,
  },
]);
```

--------------------------------

### Stage and Commit Changes

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/CONTRIBUTING.md

Add all modified files and commit them with a descriptive message.

```bash
git add .
git commit -m "Add example: description of your example"
```

--------------------------------

### Create Group and Handle Welcome Messages with XMTP Agent

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/managing-groups/SKILL.md

Use this code to create a new group conversation with specified addresses and set up event listeners for sending welcome messages to new group members or direct messages.

```typescript
const group = await agent.createGroupWithAddresses(addresses, {
  groupName: "My Group",
  groupDescription: "A cool group",
});
```

```typescript
agent.on("group", async (ctx) => {
  await ctx.conversation.sendText("Hello group!");
});
```

```typescript
agent.on("dm", async (ctx) => {
  await ctx.conversation.sendText("Hello! How can I help?");
});
```

--------------------------------

### Receive and log attachment details

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/handling-attachments/rules/receive-attachment.md

Use this snippet to receive an attachment, download its content, and log its filename, MIME type, and size. Requires the `@xmtp/agent-sdk` package.

```typescript
import { downloadRemoteAttachment } from "@xmtp/agent-sdk";

agent.on("attachment", async (ctx) => {
  const attachment = await downloadRemoteAttachment(ctx.message.content);

  console.log(`Filename: ${attachment.filename}`);
  console.log(`MIME type: ${attachment.mimeType}`);
  console.log(`Size: ${attachment.content.byteLength} bytes`);
});

```

--------------------------------

### Confirmation Dialog Without Cancel Handler

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/creating-inline-actions/rules/helpers-confirmation.md

This example shows how to send a confirmation dialog when only a 'Yes' action is required. A default cancel handler will be automatically applied, sending an '❌ Cancelled' message if the user chooses not to proceed.

```typescript
// Default cancel handler sends "❌ Cancelled"
await sendConfirmation(
  ctx,
  "Proceed with action?",
  async (ctx) => {
    await ctx.conversation.sendText("Proceeding...");
  }
);
```

--------------------------------

### Create ERC-20 Transfer Calls and Get Balance

Source: https://context7.com/xmtplabs/xmtp-agent-examples/llms.txt

Use `createERC20TransferCalls` to generate EIP-5792 transaction requests for ERC-20 token transfers. Handle `transaction-reference` events to confirm payments. Ensure necessary imports and environment variables are set.

```typescript
import {
  Agent,
  createERC20TransferCalls,
  getERC20Balance,
  getERC20Decimals,
  validHex,
} from "@xmtp/agent-sdk";
import { formatUnits, parseUnits } from "viem";
import { base, baseSepolia } from "viem/chains";

process.loadEnvFile(".env");
const agent = await Agent.createFromEnv();

const CHAIN = baseSepolia; // base for mainnet
const USDC_ADDRESS = "0x036CbD53842c5426634e7929541eC2318f3dCF7e" as `0x${string}`;
const DECIMALS = await getERC20Decimals({ chain: CHAIN, tokenAddress: USDC_ADDRESS });

// Request a USDC payment from the user
agent.on("text", async (ctx) => {
  if (ctx.message.content !== "/pay") return;

  const from = await ctx.getSenderAddress();
  const calls = createERC20TransferCalls({
    chain: CHAIN,
    tokenAddress: USDC_ADDRESS,
    from: validHex(from),
    to: validHex(agent.address),
    amount: parseUnits("1", DECIMALS), // 1 USDC
    description: "Pay 1 USDC to agent",
  });

  // Check sender balance first
  const balance = await getERC20Balance({ chain: CHAIN, tokenAddress: USDC_ADDRESS, address: validHex(from) });
  await ctx.conversation.sendText(`Your balance: ${formatUnits(balance, DECIMALS)} USDC`);
  await ctx.conversation.sendWalletSendCalls(calls);
});

// Confirm completed transactions
agent.on("transaction-reference", async (ctx) => {
  // Handle Coinbase Wallet's non-standard nested format as well
  // @ts-expect-error - Coinbase Wallet wraps incorrectly
  let ref = ctx.message.content.transactionReference;
  if (ref?.transactionReference) ref = ref.transactionReference;
  else ref = ctx.message.content;

  await ctx.conversation.sendText(
    `✅ Transaction confirmed!\n🔗 Network: ${ref.networkId}\n📄 Hash: ${ref.reference}`
  );
});

await agent.start();
```

--------------------------------

### Environment Variables for XMTP Agent

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-transactions/README.md

Required environment variables for running the XMTP agent, including wallet keys, encryption keys, and network configuration.

```bash
XMTP_WALLET_KEY= # the private key for the wallet
XMTP_DB_ENCRYPTION_KEY= # the encryption key for the wallet

NETWORK_ID=base-sepolia # base-mainnet or others
XMTP_ENV=dev # local, dev, production
```

--------------------------------

### Manual Agent Creation (Incorrect)

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/building-agents/rules/setup-from-env.md

Avoid manual configuration for agent creation. This method requires explicitly passing signer and configuration options.

```typescript
import { Agent, createSigner, createUser, validHex } from "@xmtp/agent-sdk";

const agent = await Agent.create(
  createSigner(createUser(validHex(process.env.XMTP_WALLET_KEY))),
  {
    env: process.env.XMTP_ENV as "local" | "dev" | "production",
    dbPath: process.env.XMTP_DB_DIRECTORY,
  }
);
```

--------------------------------

### Set Optional XMTP Environment Variables

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/building-agents/rules/setup-environment.md

Configure optional environment variables for your XMTP agent. XMTP_DB_DIRECTORY specifies the database location, and XMTP_FORCE_DEBUG_LEVEL enables debug logging for SDK 2.0+.

```bash
# Database directory (defaults to current working directory)
XMTP_DB_DIRECTORY=./data

# Debug logging (SDK 2.0+)
XMTP_FORCE_DEBUG_LEVEL=Debug
```

--------------------------------

### Create Group with Full Options

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/managing-groups/rules/create-group.md

Create a group conversation with comprehensive options including name, description, and a square image URL.

```typescript
const group = await agent.createGroupWithAddresses(addresses, {
  groupName: "Project Discussion",
  groupDescription: "A group for our project collaboration",
  groupImageUrlSquare: "https://example.com/image.jpg",
});
```

--------------------------------

### Command Routing with `CommandRouter`

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/AGENTS.md

Shows how to use `CommandRouter` to define and register command handlers for an agent, enabling structured command processing.

```typescript
import { Agent, CommandRouter } from "@xmtp/agent-sdk";

const router = new CommandRouter();
router.command("/help", async (ctx) => { ... });
agent.use(router.middleware());
```

--------------------------------

### CLI Debugging for XMTP Agents

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/README.md

Utilize the command line interface for debugging XMTP agents, with options to debug all agents or a specific agent by its address.

```bash
yarn debug
yarn debug --agent 0x81bddb3d7cd9ccdfaeb117ce19fd77c1433b907d
```

--------------------------------

### ActionBuilder Class for Creating Interactive Menus

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/creating-inline-actions/SKILL.md

A utility class to programmatically build and send interactive action menus. Use this to define menu IDs, descriptions, and add buttons with specific IDs and labels.

```typescript
import { ActionStyle } from "@xmtp/node-sdk";

class ActionBuilder {
  private actions: { id: string; label: string; style?: ActionStyle }[] = [];
  constructor(private id: string, private description: string) {}
  
  static create(id: string, description: string) {
    return new ActionBuilder(id, description);
  }
  
  add(id: string, label: string, style?: ActionStyle) {
    this.actions.push({ id, label, style });
    return this;
  }
  
  async send(ctx: MessageContext) {
    await ctx.conversation.sendActions({
      id: this.id,
      description: this.description,
      actions: this.actions,
    });
  }
}
```

--------------------------------

### Environment Variables for XMTP Agent

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-smart-wallet/README.md

Configure your XMTP agent by setting these environment variables in a .env file. These include API keys, network IDs, and encryption keys.

```bash
XMTP_WALLET_KEY= # the private key for the wallet
XMTP_DB_ENCRYPTION_KEY= # the encryption key for the wallet

NETWORK_ID=base-sepolia # base-mainnet or others
CDP_API_KEY_NAME= # the name of the CDP API key
CDP_API_KEY_PRIVATE_KEY= # the private key for the CDP API key
XMTP_ENV=dev # local, dev, production
```

--------------------------------

### XMTP Agent Welcome Message Implementation

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-welcome-message/README.md

This TypeScript code defines a shared function to send a welcome message with interactive buttons and sets up event handlers for new direct messages and group conversations.

```typescript
import { Agent, Conversation, ConversationContext } from "@xmtp/agent-sdk";

// Shared welcome message function
async function sendWelcomeMessage(
  ctx: ConversationContext<unknown, Conversation>,
) {
  const welcomeActions = ActionBuilder.create(
    `welcome-${Date.now()}`,
    `👋 Welcome! I'm your ETH price agent...`,
  )
    .add("get-current-price", "💰 Get Current ETH Price")
    .add("get-price-chart", "📊 Get Price with 24h Change")
    .build();

  await sendActions(ctx.conversation, welcomeActions);
}

// Listen for new DM conversations
agent.on("dm", async (ctx) => {
  sendWelcomeMessage(ctx);
});

// Listen for new Group conversations
agent.on("group", async (ctx) => {
  sendWelcomeMessage(ctx);
});
```

--------------------------------

### Bash Commands for XMTP Transactions

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/examples/xmtp-transactions/README.md

Basic bash commands for interacting with the XMTP agent, including sending transaction requests and checking balances.

```bash
# send a transaction request
/tx <amount>

# check your balance
/balance
```

--------------------------------

### Send Basic Selection Menu

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/creating-inline-actions/rules/helpers-selection.md

Use `sendSelection` to present a list of options to the user. Each option has an ID, a display label, and a handler function that executes when the option is selected. Ensure the `sendSelection` utility is imported.

```typescript
import { sendSelection } from "../../utils/inline-actions";

await sendSelection(ctx, "Pick a color:", [
  {
    id: "red",
    label: "🔴 Red",
    handler: async (ctx) => {
      await ctx.conversation.sendText("You picked red!");
    },
  },
  {
    id: "blue",
    label: "🔵 Blue",
    handler: async (ctx) => {
      await ctx.conversation.sendText("You picked blue!");
    },
  },
  {
    id: "green",
    label: "🟢 Green",
    handler: async (ctx) => {
      await ctx.conversation.sendText("You picked green!");
    },
  },
]);
```

--------------------------------

### Correct command handling with CommandRouter

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/building-agents/rules/middleware-command-router.md

Set up CommandRouter to handle specific slash commands and define a default handler for unrecognized commands. Apply the router's middleware to your agent.

```typescript
import { CommandRouter } from "@xmtplp/agent-sdk";

const router = new CommandRouter();

router.command("/balance", async (ctx) => {
  await ctx.conversation.sendText("Your balance is: 100 USDC");
});

router.command("/help", async (ctx) => {
  await ctx.conversation.sendText("Available commands: /balance, /help");
});

// Default handler for non-command messages
router.default(async (ctx) => {
  const commands = router.commandList;
  await ctx.conversation.sendText(`Unknown command. Try: ${commands.join(", ")}`);
});

// Apply middleware
agent.use(router.middleware());
```

--------------------------------

### Basic Domain Name Resolution

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/resolving-domains/rules/resolve-address.md

Use `createNameResolver` to initialize a resolver instance. This function can convert ENS, Farcaster, and Basename domains into Ethereum addresses. An optional API key can be provided for higher rate limits.

```typescript
import { createNameResolver } from "@xmtp/agent-sdk";

const resolver = createNameResolver(process.env.WEB3_BIO_API_KEY || "");

// Resolve ENS name
const address = await resolver("vitalik.eth");
console.log(address); // "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"

// Resolve Farcaster name  
const fcAddress = await resolver("dwr.farcaster.eth");

// Resolve Basename
const baseAddress = await resolver("tony.base.eth");
```

--------------------------------

### Display a Menu

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/creating-inline-actions/rules/config-menus.md

Show a specific menu to the user in response to a text message. This requires the context, the app configuration, and the ID of the menu to display.

```typescript
agent.on("text", async (ctx) => {
  const text = ctx.message.content.toLowerCase();
  if (text === "menu" || text === "hi") {
    await showMenu(ctx, config, "main-menu");
  }
});
```

--------------------------------

### Add Members to a Group

Source: https://github.com/xmtplabs/xmtp-agent-examples/blob/main/skills/managing-groups/rules/members-add.md

Demonstrates how to add members to a group using either their inbox IDs or by providing their Ethereum addresses.

```APIDOC
## Add Members

### Description
Adds one or more members to a group.

### Method
`group.addMembers(inboxIds: string[])`
`group.addMembersByIdentifiers(identifiers: { identifier: string, identifierKind: IdentifierKind }[])`

### Parameters
#### `addMembers`
- **inboxIds** (string[]) - Required - An array of inbox IDs to add to the group.

#### `addMembersByIdentifiers`
- **identifiers** ({ identifier: string, identifierKind: IdentifierKind }[]) - Required - An array of objects, where each object contains an identifier and its kind (e.g., `IdentifierKind.Ethereum`).

### Request Example
```typescript
// Add by inbox ID
await group.addMembers(["inboxId1", "inboxId2"]);

// Add by Ethereum address
import { IdentifierKind } from "@xmtpl/agent-sdk";

await group.addMembersByIdentifiers([
  {
    identifier: "0x123...",
    identifierKind: IdentifierKind.Ethereum,
  },
]);
```
```
Tokens:
Raw