@towns-labs/agent 2.0.1

package/dist/agent.test.js

@@ -0,0 +1,1315 @@
+import { makeBaseProvider, makeUserStreamId, townsEnv, RiverTimelineEvent, waitFor, Bot as SyncAgentTest, AppRegistryService, MessageType, genIdBlob, makeUniqueMediaStreamId, createApp, } from '@towns-labs/sdk';
+import { describe, it, expect, beforeAll, afterEach, vi } from 'vitest';
+import { bin_fromHexString, dlog } from '@towns-labs/utils';
+import { makeTownsAgent } from './agent';
+import { ethers } from 'ethers';
+import { createPublicClient, http } from 'viem';
+import { relayerActions } from '@towns-labs/relayer-client';
+import { getAddressesWithFallback } from '@towns-labs/contracts/deployments';
+import { z } from 'zod';
+import { stringify as superjsonStringify } from 'superjson';
+import { ForwardSettingValue, InteractionRequestPayload_Signature_SignatureType, MediaInfoSchema, } from '@towns-labs/proto';
+import { ETH_ADDRESS } from '@towns-labs/web3';
+import { createServer } from 'node:http2';
+import { serve } from '@hono/node-server';
+import { randomUUID } from 'crypto';
+import { nanoid } from 'nanoid';
+import { create } from '@bufbuild/protobuf';
+import { deriveKeyAndIV } from '@towns-labs/sdk-crypto';
+const log = dlog('test:bot');
+const WEBHOOK_URL = `https://localhost:${process.env.BOT_PORT}/webhook`;
+const SLASH_COMMANDS = [
+    { name: 'help', description: 'Get help with bot commands' },
+    { name: 'status', description: 'Check bot status' },
+];
+describe('Bot', { sequential: true }, () => {
+    const subscriptions = [];
+    const townsConfig = townsEnv().makeTownsConfig();
+    const bob = new SyncAgentTest(undefined, townsConfig);
+    let bobClient;
+    const alice = new SyncAgentTest(undefined, townsConfig);
+    let aliceClient;
+    const carol = new SyncAgentTest(undefined, townsConfig);
+    let carolClient;
+    const BOT_USERNAME = `bot-witness-of-infinity-${randomUUID()}`;
+    const BOT_DISPLAY_NAME = 'Uber Test Bot';
+    const BOT_DESCRIPTION = 'I shall witness everything';
+    let bot;
+    let channelId;
+    let botClientAddress;
+    let appPrivateData;
+    let jwtSecretBase64;
+    let appRegistryRpcClient;
+    let appAddress;
+    let bobDefaultGdm;
+    let ethersProvider;
+    beforeAll(async () => {
+        ethersProvider = makeBaseProvider(townsConfig);
+        await shouldInitializeBotOwner();
+        await shouldSetupBotUser();
+        await shouldRegisterBotInAppRegistry();
+        await shouldRunBotServerAndRegisterWebhook();
+        await bobClient.riverConnection.call((client) => Promise.all([client.debugForceMakeMiniblock(channelId, { forceSnapshot: true })]));
+    });
+    afterEach(() => {
+        subscriptions.forEach((unsub) => unsub());
+        subscriptions.splice(0, subscriptions.length);
+    });
+    const setForwardSetting = async (forwardSetting) => {
+        await appRegistryRpcClient.setAppSettings({
+            appId: bin_fromHexString(botClientAddress),
+            settings: { forwardSetting },
+        });
+    };
+    const shouldInitializeBotOwner = async () => {
+        await Promise.all([bob.fundWallet(), alice.fundWallet(), carol.fundWallet()]);
+        bobClient = await bob.makeSyncAgent();
+        aliceClient = await alice.makeSyncAgent();
+        carolClient = await carol.makeSyncAgent();
+        await Promise.all([bobClient.start(), aliceClient.start(), carolClient.start()]);
+        const { streamId: gdmId } = await bobClient.gdms.createGDM([
+            { userId: alice.userId },
+            { userId: carol.userId },
+        ]);
+        channelId = gdmId;
+        await bobClient.riverConnection.call((client) => client.waitForStream(gdmId));
+        bobDefaultGdm = bobClient.gdms.getGdm(gdmId);
+        expect(channelId).toBeDefined();
+    };
+    const shouldSetupBotUser = async () => {
+        const chainId = townsConfig.base.chainConfig.chainId;
+        const addresses = getAddressesWithFallback(townsConfig.environmentId, chainId);
+        if (!addresses?.accountProxy) {
+            throw new Error(`No accountProxy address found for ${townsConfig.environmentId}/${chainId}`);
+        }
+        const relayerUrl = process.env.RELAYER_URL ?? 'http://127.0.0.1:8787';
+        const relayerClient = createPublicClient({
+            chain: {
+                id: chainId,
+                name: 'Test Chain',
+                nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+                rpcUrls: { default: { http: [townsConfig.base.rpcUrl] } },
+            },
+            transport: http(townsConfig.base.rpcUrl),
+        }).extend(relayerActions({ relayerUrl }));
+        const result = await createApp({
+            owner: bobClient.riverConnection.signerContext,
+            metadata: {
+                username: BOT_USERNAME,
+                displayName: BOT_DISPLAY_NAME,
+                description: BOT_DESCRIPTION,
+                imageUrl: 'https://placehold.co/600x600',
+                slashCommands: SLASH_COMMANDS,
+            },
+            relayerClient,
+            accountProxy: addresses.accountProxy,
+            townsConfig,
+        });
+        botClientAddress = result.appAddress;
+        appPrivateData = result.appPrivateData;
+        appAddress = result.appAddress;
+        jwtSecretBase64 = result.jwtSecretBase64;
+        expect(appPrivateData).toBeDefined();
+        expect(jwtSecretBase64).toBeDefined();
+        await bobClient.riverConnection.call((client) => client.joinUser(channelId, botClientAddress));
+    };
+    const shouldRegisterBotInAppRegistry = async () => {
+        const appRegistryUrl = townsEnv().getAppRegistryUrl(process.env.RIVER_ENV);
+        const { appRegistryRpcClient: rpcClient } = await AppRegistryService.authenticateWithSigner(bob.userId, bob.signer, appRegistryUrl);
+        appRegistryRpcClient = rpcClient;
+    };
+    const shouldRunBotServerAndRegisterWebhook = async () => {
+        bot = await makeTownsAgent(appPrivateData, jwtSecretBase64, { commands: SLASH_COMMANDS });
+        expect(bot).toBeDefined();
+        expect(bot.agentUserId).toBe(botClientAddress);
+        expect(bot.appAddress).toBe(appAddress);
+        const app = bot.start();
+        serve({
+            port: Number(process.env.BOT_PORT),
+            fetch: app.fetch,
+            createServer,
+        });
+        await appRegistryRpcClient.registerWebhook({
+            appId: bin_fromHexString(botClientAddress),
+            webhookUrl: WEBHOOK_URL,
+        });
+        const { isRegistered, validResponse } = await appRegistryRpcClient.getStatus({
+            appId: bin_fromHexString(botClientAddress),
+        });
+        expect(isRegistered).toBe(true);
+        expect(validResponse).toBe(true);
+    };
+    it('should have app_address defined in user stream for bot (app registry only)', async () => {
+        const botUserStreamId = makeUserStreamId(botClientAddress);
+        const streamView = await bobClient.riverConnection.call(async (client) => {
+            return await client.getStream(botUserStreamId);
+        });
+        const userStream = streamView.userContent.userStreamModel;
+        expect(userStream.appAddress).toBeDefined();
+        // expect(userStream.appAddress).toBe(botClientAddress)
+    });
+    it('should show bot in member list and apps set', async () => {
+        const channelStreamView = await bobClient.riverConnection.call(async (client) => {
+            return await client.getStream(channelId);
+        });
+        const { apps, joined } = channelStreamView.getMembers();
+        expect(apps.has(botClientAddress)).toBe(true);
+        expect(joined.has(botClientAddress)).toBe(true);
+        expect(joined.get(botClientAddress)?.appAddress).toBe(appAddress);
+    });
+    it('should receive a message forwarded', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const timeBeforeSendMessage = Date.now();
+        let receivedMessages = [];
+        subscriptions.push(bot.onMessage((_h, e) => {
+            receivedMessages.push(e);
+        }));
+        const TEST_MESSAGE = 'Hello bot!';
+        const { eventId } = await bobDefaultGdm.sendMessage(TEST_MESSAGE);
+        await waitFor(() => receivedMessages.length > 0, { timeoutMS: 15_000 });
+        const event = receivedMessages.find((x) => x.eventId === eventId);
+        expect(event?.message).toBe(TEST_MESSAGE);
+        expect(event?.createdAt).toBeDefined();
+        expect(event?.createdAt).toBeInstanceOf(Date);
+        expect(event?.createdAt.getTime()).toBeGreaterThanOrEqual(timeBeforeSendMessage);
+        receivedMessages = [];
+    });
+    it('should not receive messages when forwarding is set to no messages', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_NO_MESSAGES);
+        const receivedMessages = [];
+        subscriptions.push(bot.onMessage((_h, e) => {
+            receivedMessages.push(e);
+        }));
+        const TEST_MESSAGE = 'This message should not be forwarded';
+        await bobDefaultGdm.sendMessage(TEST_MESSAGE);
+        await new Promise((resolve) => setTimeout(resolve, 2500));
+        expect(receivedMessages).toHaveLength(0);
+    });
+    it('should receive slash command messages', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedMessages = [];
+        subscriptions.push(bot.onSlashCommand('help', (_h, e) => {
+            receivedMessages.push(e);
+        }));
+        const { eventId } = await bobDefaultGdm.sendMessage('/help', {
+            appClientAddress: bot.agentUserId,
+        });
+        await waitFor(() => receivedMessages.length > 0);
+        const event = receivedMessages.find((x) => x.eventId === eventId);
+        expect(event?.command).toBe('help');
+        expect(event?.args).toStrictEqual([]);
+    });
+    it('should receive slash command in a thread', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedMessages = [];
+        subscriptions.push(bot.onSlashCommand('help', (_h, e) => {
+            receivedMessages.push(e);
+        }));
+        const { eventId: threadId } = await bobDefaultGdm.sendMessage('starting a thread');
+        const { eventId } = await bobDefaultGdm.sendMessage('/help', {
+            appClientAddress: bot.agentUserId,
+            threadId: threadId,
+        });
+        await waitFor(() => receivedMessages.length > 0);
+        const event = receivedMessages.find((x) => x.eventId === eventId);
+        expect(event?.command).toBe('help');
+        expect(event?.args).toStrictEqual([]);
+        expect(event?.threadId).toBe(threadId);
+    });
+    it('should receive slash command as a reply', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedMessages = [];
+        subscriptions.push(bot.onSlashCommand('help', (_h, e) => {
+            receivedMessages.push(e);
+        }));
+        const { eventId: replyId } = await bobDefaultGdm.sendMessage('yo');
+        const { eventId } = await bobDefaultGdm.sendMessage('/help', {
+            appClientAddress: bot.agentUserId,
+            replyId: replyId,
+        });
+        await waitFor(() => receivedMessages.length > 0);
+        const event = receivedMessages.find((x) => x.eventId === eventId);
+        expect(event?.command).toBe('help');
+        expect(event?.args).toStrictEqual([]);
+        expect(event?.replyId).toBe(replyId);
+    });
+    it('should receive slash command with arguments', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedMessages = [];
+        subscriptions.push(bot.onSlashCommand('status', (_h, e) => {
+            receivedMessages.push(e);
+        }));
+        const { eventId } = await bobDefaultGdm.sendMessage('/status detailed info', {
+            appClientAddress: bot.agentUserId,
+        });
+        await waitFor(() => receivedMessages.length > 0);
+        const event = receivedMessages.find((x) => x.eventId === eventId);
+        expect(event?.command).toBe('status');
+        expect(event?.args).toStrictEqual(['detailed', 'info']);
+    });
+    it('onMessageEdit should be triggered when a message is edited', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedEditEvents = [];
+        subscriptions.push(bot.onMessageEdit((_h, e) => {
+            receivedEditEvents.push(e);
+        }));
+        const originalMessage = 'Original message to delete';
+        const editedMessage = 'Edited message content';
+        const { eventId: originalMessageId } = await bobDefaultGdm.sendMessage(originalMessage);
+        await bobClient.riverConnection.call((client) => client.sendChannelMessage_Edit_Text(channelId, originalMessageId, {
+            content: {
+                body: editedMessage,
+                mentions: [],
+                attachments: [],
+            },
+        }));
+        await waitFor(() => receivedEditEvents.length > 0);
+        const editEvent = receivedEditEvents.find((e) => e.refEventId === originalMessageId);
+        expect(editEvent).toBeDefined();
+        expect(editEvent?.message).toBe(editedMessage);
+    });
+    it('onMessage should be triggered with threadId when a message is sent in a thread', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedThreadMessages = [];
+        subscriptions.push(bot.onMessage((_h, e) => {
+            if (e.threadId) {
+                receivedThreadMessages.push(e);
+            }
+        }));
+        const initialMessage = 'Starting a thread';
+        const threadReply = 'Replying in thread';
+        const { eventId: initialMessageId } = await bobDefaultGdm.sendMessage(initialMessage);
+        const { eventId: replyEventId } = await bobDefaultGdm.sendMessage(threadReply, {
+            threadId: initialMessageId,
+        });
+        await waitFor(() => receivedThreadMessages.length > 0);
+        const threadEvent = receivedThreadMessages.find((e) => e.eventId === replyEventId);
+        expect(threadEvent).toBeDefined();
+        expect(threadEvent?.message).toBe(threadReply);
+        expect(threadEvent?.userId).toBe(bob.userId);
+        expect(threadEvent?.threadId).toBe(initialMessageId);
+    });
+    it('onMessage should be triggered with isMentioned when a bot is mentioned', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedMentionedEvents = [];
+        subscriptions.push(bot.onMessage((_h, e) => {
+            if (e.isMentioned) {
+                receivedMentionedEvents.push(e);
+            }
+        }));
+        const TEST_MESSAGE = 'Hello @bot';
+        const { eventId } = await bobDefaultGdm.sendMessage(TEST_MESSAGE, {
+            mentions: [
+                {
+                    userId: bot.agentUserId,
+                    displayName: BOT_DISPLAY_NAME,
+                    mentionBehavior: { case: undefined, value: undefined },
+                },
+            ],
+        });
+        await waitFor(() => receivedMentionedEvents.length > 0);
+        const mentionedEvent = receivedMentionedEvents.find((x) => x.eventId === eventId);
+        expect(mentionedEvent).toBeDefined();
+        expect(mentionedEvent?.isMentioned).toBe(true);
+        expect(mentionedEvent?.mentions[0].userId).toBe(bot.agentUserId);
+        expect(mentionedEvent?.mentions[0].displayName).toBe(BOT_DISPLAY_NAME);
+    });
+    it('isMentioned should be false when someone else is mentioned', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedMessages = [];
+        subscriptions.push(bot.onMessage((_h, e) => {
+            receivedMessages.push(e);
+        }));
+        const TEST_MESSAGE = 'Hello @alice';
+        const { eventId } = await bobDefaultGdm.sendMessage(TEST_MESSAGE, {
+            mentions: [
+                {
+                    userId: alice.userId,
+                    displayName: 'alice',
+                    mentionBehavior: { case: undefined, value: undefined },
+                },
+            ],
+        });
+        await waitFor(() => receivedMessages.length > 0);
+        const message = receivedMessages.find((x) => x.eventId === eventId);
+        expect(message).toBeDefined();
+        expect(message?.isMentioned).toBe(false);
+    });
+    it('onMessage should be triggered with both threadId and isMentioned when bot is mentioned in a thread', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedMentionedInThreadEvents = [];
+        subscriptions.push(bot.onMessage((_h, e) => {
+            receivedMentionedInThreadEvents.push(e);
+        }));
+        const { eventId: initialMessageId } = await bobDefaultGdm.sendMessage('starting a thread');
+        const { eventId: threadMentionEventId } = await bobDefaultGdm.sendMessage('yo @bot check this thread', {
+            threadId: initialMessageId,
+            mentions: [
+                {
+                    userId: bot.agentUserId,
+                    displayName: bot.agentUserId,
+                    mentionBehavior: { case: undefined, value: undefined },
+                },
+            ],
+        });
+        await waitFor(() => receivedMentionedInThreadEvents.length > 0);
+        const threadMentionEvent = receivedMentionedInThreadEvents.find((e) => e.eventId === threadMentionEventId);
+        expect(threadMentionEvent).toBeDefined();
+        expect(threadMentionEvent?.userId).toBe(bob.userId);
+        expect(threadMentionEvent?.threadId).toBe(initialMessageId);
+        expect(threadMentionEvent?.isMentioned).toBe(true);
+    });
+    it('thread message without bot mention should have isMentioned false', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedMessages = [];
+        subscriptions.push(bot.onMessage((_h, e) => {
+            receivedMessages.push(e);
+        }));
+        const initialMessage = 'Starting another thread';
+        const threadMessageWithoutMention = 'Thread message without mention';
+        const { eventId: initialMessageId } = await bobDefaultGdm.sendMessage(initialMessage);
+        const { eventId: threadEventId } = await bobDefaultGdm.sendMessage(threadMessageWithoutMention, {
+            threadId: initialMessageId,
+        });
+        await waitFor(() => receivedMessages.length > 0);
+        const message = receivedMessages.find((x) => x.eventId === threadEventId);
+        expect(message).toBeDefined();
+        expect(message?.threadId).toBe(initialMessageId);
+        expect(message?.isMentioned).toBe(false);
+    });
+    it('onReaction should be triggered when a reaction is added', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedReactionEvents = [];
+        subscriptions.push(bot.onReaction((_h, e) => {
+            receivedReactionEvents.push(e);
+        }));
+        const { eventId: messageId } = await bobDefaultGdm.sendMessage('Hello');
+        const { eventId: reactionId } = await bobDefaultGdm.sendReaction(messageId, '👍');
+        await waitFor(() => receivedReactionEvents.length > 0);
+        expect(receivedReactionEvents.find((x) => x.eventId === reactionId)).toBeDefined();
+        expect(receivedReactionEvents.find((x) => x.reaction === '👍')).toBeDefined();
+        expect(receivedReactionEvents.find((x) => x.messageId === messageId)).toBeDefined();
+        expect(receivedReactionEvents.find((x) => x.userId === bob.userId)).toBeDefined();
+    });
+    it('onRedaction should be triggered when a message is redacted', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedRedactionEvents = [];
+        subscriptions.push(bot.onRedaction((_h, e) => {
+            receivedRedactionEvents.push(e);
+        }));
+        const { eventId: messageId } = await bobDefaultGdm.sendMessage('Hello');
+        const { eventId: redactionId } = await bobDefaultGdm.redact(messageId);
+        await waitFor(() => receivedRedactionEvents.length > 0);
+        expect(receivedRedactionEvents.find((x) => x.eventId === redactionId)).toBeDefined();
+    });
+    it('bot can redact his own message', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const { eventId: messageId } = await bot.sendMessage(channelId, 'Hello');
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === messageId)?.content
+            ?.kind).toBe(RiverTimelineEvent.ChannelMessage));
+        const { eventId: redactionId } = await bot.removeEvent(channelId, messageId);
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === redactionId)?.content
+            ?.kind).toBe(RiverTimelineEvent.RedactionActionEvent));
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === messageId)?.content
+            ?.kind).toBe(RiverTimelineEvent.RedactedEvent));
+    });
+    it('bot can mention bob', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const { eventId: messageId } = await bot.sendMessage(channelId, 'Hello @bob', {
+            mentions: [
+                {
+                    userId: bob.userId,
+                    displayName: 'bob',
+                },
+            ],
+        });
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === messageId)?.content
+            ?.kind).toBe(RiverTimelineEvent.ChannelMessage));
+        const channelMessage = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === messageId)?.content;
+        expect(channelMessage.mentions).toBeDefined();
+        expect(channelMessage.mentions?.length).toBe(1);
+        expect(channelMessage.mentions?.[0].userId).toBe(bob.userId);
+        expect(channelMessage.mentions?.[0].displayName).toBe('bob');
+    });
+    it('bot can fetch existing decryption keys when sending a message', async () => {
+        // on a fresh boot the bot won't have any keys in cache, so it should fetch them from the app server if they exist
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const { eventId: messageId1 } = await bot.sendMessage(channelId, 'Hello message 1');
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === messageId1)?.content
+            ?.kind).toBe(RiverTimelineEvent.ChannelMessage));
+        // DELETE OUTBOUND GROUP SESSIONS to simulate fresh server start
+        await bot['client'].crypto.cryptoStore.deleteOutboundGrounpSessions(channelId);
+        await bot['client'].crypto.cryptoStore.deleteHybridGroupSessions(channelId);
+        const { eventId: messageId2 } = await bot.sendMessage(channelId, 'Hello message 2');
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === messageId2)?.content
+            ?.kind).toBe(RiverTimelineEvent.ChannelMessage));
+        const event1 = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === messageId1);
+        const event2 = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === messageId2);
+        expect(event1?.sessionId).toEqual(event2?.sessionId);
+    });
+    it('bot shares new decrytion keys with users created while sending a message', async () => {
+        // the bot should almost never have to create a new key - usually they will get a message in the gdm first and can use that key to encrypt
+        // but in the case where they've never received one and want to send a message, they will create a new key and share it with the users in the gdm
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const { streamId: gdmId } = await bobClient.gdms.createGDM([
+            { userId: alice.userId },
+            { userId: bot.agentUserId, appAddress: bot.appAddress },
+        ]);
+        await bobClient.riverConnection.call((client) => client.waitForStream(gdmId));
+        const bobGdm = bobClient.gdms.getGdm(gdmId);
+        // bot sends message to the gdm
+        const { eventId: messageId } = await bot.sendMessage(gdmId, 'Hello');
+        log('bot sends message to gdm', messageId);
+        // bob should see the DECRYPTED message
+        await waitFor(() => {
+            expect(bobGdm.timeline.events.value.find((x) => x.eventId === messageId)?.content
+                ?.kind).toBe(RiverTimelineEvent.ChannelMessage);
+        }, { timeoutMS: 20000 });
+    });
+    it.skip('TODO: FIX: onTip should be triggered when a tip is received', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedTipEvents = [];
+        subscriptions.push(bot.onTip((_h, e) => {
+            receivedTipEvents.push(e);
+        }));
+        // Bot sends a message to the GDM
+        const { eventId: messageId } = await bot.sendMessage(channelId, 'Tip me!');
+        const balanceBefore = (await ethersProvider.getBalance(appAddress)).toBigInt();
+        // Bob tips the bot using GDM sendTip (type: 'any' tipping)
+        await bobDefaultGdm.sendTip(messageId, {
+            receiver: appAddress,
+            amount: ethers.utils.parseUnits('0.01').toBigInt(),
+            currency: ETH_ADDRESS,
+            chainId: townsConfig.base.chainConfig.chainId,
+        }, bob.signer);
+        // Verify the bot's balance increased (no protocol fee for type: 'any' tips)
+        const balanceAfter = (await ethersProvider.getBalance(appAddress)).toBigInt();
+        const expectedTipAmount = ethers.utils.parseUnits('0.01').toBigInt();
+        expect(balanceAfter).toEqual(balanceBefore + expectedTipAmount);
+        // Verify the onTip event was triggered
+        await waitFor(() => receivedTipEvents.length > 0);
+        const tipEvent = receivedTipEvents.find((x) => x.messageId === messageId);
+        expect(tipEvent).toBeDefined();
+        expect(tipEvent?.userId).toBe(bob.userId);
+        expect(tipEvent?.channelId).toBe(channelId);
+        expect(tipEvent?.amount).toBe(expectedTipAmount);
+        expect(tipEvent?.currency).toBe(ETH_ADDRESS);
+        expect(tipEvent?.senderAddress).toBe(bob.userId);
+        expect(tipEvent?.receiverAddress).toBe(appAddress);
+    });
+    it.skip('TODO: FIX: bot can use sendTip() to send tips using app balance', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedMessages = [];
+        let tipPromise;
+        subscriptions.push(bot.onMessage((handler, event) => {
+            receivedMessages.push(event);
+            tipPromise = handler.sendTip({
+                userId: bob.userId,
+                amount: ethers.utils.parseUnits('0.005').toBigInt(),
+                messageId: event.eventId,
+                channelId: event.channelId,
+            });
+        }));
+        const bobBalanceBefore = (await ethersProvider.getBalance(bob.userId)).toBigInt();
+        // Bob sends a message asking for a tip
+        const { eventId: bobMessageId } = await bobDefaultGdm.sendMessage('Tip me please!');
+        await waitFor(() => receivedMessages.some((x) => x.eventId === bobMessageId));
+        expect(tipPromise).toBeDefined();
+        const result = await tipPromise;
+        expect(result.txHash).toBeDefined();
+        expect(result.eventId).toBeDefined();
+        // Verify bob's balance increased
+        const bobBalanceAfter = (await ethersProvider.getBalance(bob.userId)).toBigInt();
+        expect(bobBalanceAfter).toBeGreaterThan(bobBalanceBefore);
+    });
+    it('onEventRevoke (FORWARD_SETTING_ALL_MESSAGES) should be triggered when a message is revoked', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedEventRevokeEvents = [];
+        subscriptions.push(bot.onEventRevoke((_h, e) => {
+            receivedEventRevokeEvents.push(e);
+        }));
+        const { eventId: messageId } = await bot.sendMessage(channelId, 'hii');
+        await bobDefaultGdm.adminRedact(messageId);
+        await waitFor(() => receivedEventRevokeEvents.length > 0);
+        expect(receivedEventRevokeEvents.find((x) => x.refEventId === messageId)).toBeDefined();
+    });
+    it.fails('onEventRevoke (FORWARD_SETTING_MENTIONS_REPLIES_REACTIONS) should be triggered when a message that mentions the bot is revoked', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_MENTIONS_REPLIES_REACTIONS);
+        const receivedEventRevokeEvents = [];
+        subscriptions.push(bot.onEventRevoke((_h, e) => {
+            receivedEventRevokeEvents.push(e);
+        }));
+        const { eventId: messageId } = await bobDefaultGdm.sendMessage('hii @bot', {
+            mentions: [
+                {
+                    userId: bot.agentUserId,
+                    displayName: bot.agentUserId,
+                    mentionBehavior: { case: undefined, value: undefined },
+                },
+            ],
+        });
+        await bobDefaultGdm.adminRedact(messageId);
+        await waitFor(() => receivedEventRevokeEvents.length > 0);
+        expect(receivedEventRevokeEvents.find((x) => x.refEventId === messageId)).toBeDefined();
+    });
+    it('should send message with image attachment from URL with alt text', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const imageUrl = 'https://placehold.co/800x600.png';
+        const altText = 'A beautiful placeholder image';
+        const { eventId } = await bot.sendMessage(channelId, 'Image with alt text', {
+            attachments: [{ type: 'image', url: imageUrl, alt: altText }],
+        });
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        const message = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+        expect(message?.content?.kind).toBe(RiverTimelineEvent.ChannelMessage);
+        const attachments = message?.content?.kind === RiverTimelineEvent.ChannelMessage
+            ? message?.content?.attachments
+            : undefined;
+        expect(attachments).toHaveLength(1);
+        expect(attachments?.[0].type).toBe('image');
+        const image = attachments?.[0].type === 'image' ? attachments?.[0] : undefined;
+        expect(image).toBeDefined();
+        expect(image?.info.url).toBe(imageUrl);
+    });
+    it('should gracefully handle non-image URL (skip with warning)', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        // Use a URL that returns non-image content type
+        const nonImageUrl = 'https://httpbin.org/json';
+        const { eventId } = await bot.sendMessage(channelId, 'This should skip the attachment', {
+            attachments: [{ type: 'image', url: nonImageUrl }],
+        });
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        // Message should still be sent, just without the attachment
+        const message = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+        expect(message?.content?.kind).toBe(RiverTimelineEvent.ChannelMessage);
+        const attachments = message?.content?.kind === RiverTimelineEvent.ChannelMessage
+            ? message?.content?.attachments
+            : undefined;
+        expect(attachments).toHaveLength(0);
+    });
+    it('should gracefully handle invalid URL (404)', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        // Use a URL that returns 404
+        const invalidUrl = 'https://httpbin.org/status/404';
+        const { eventId } = await bot.sendMessage(channelId, 'This should handle 404 gracefully', {
+            attachments: [{ type: 'image', url: invalidUrl }],
+        });
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        // Message should still be sent, just without the attachment
+        const message = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+        expect(message?.content?.kind).toBe(RiverTimelineEvent.ChannelMessage);
+    });
+    function createTestPNG(width, height) {
+        // PNG signature
+        const signature = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+        // IHDR chunk
+        const ihdrData = new Uint8Array(13);
+        const view = new DataView(ihdrData.buffer);
+        view.setUint32(0, width, false); // Width
+        view.setUint32(4, height, false); // Height
+        ihdrData[8] = 8; // Bit depth
+        ihdrData[9] = 2; // Color type (truecolor)
+        ihdrData[10] = 0; // Compression
+        ihdrData[11] = 0; // Filter
+        ihdrData[12] = 0; // Interlace
+        // Create IHDR chunk with CRC
+        const ihdrChunk = new Uint8Array(12 + 13);
+        new DataView(ihdrChunk.buffer).setUint32(0, 13, false);
+        ihdrChunk.set([73, 72, 68, 82], 4); // 'IHDR'
+        ihdrChunk.set(ihdrData, 8);
+        new DataView(ihdrChunk.buffer).setUint32(21, 0, false); // CRC placeholder
+        // IDAT chunk (minimal data)
+        const idatData = new Uint8Array(100); // Minimal compressed data
+        const idatChunk = new Uint8Array(12 + 100);
+        new DataView(idatChunk.buffer).setUint32(0, 100, false);
+        idatChunk.set([73, 68, 65, 84], 4); // 'IDAT'
+        idatChunk.set(idatData, 8);
+        new DataView(idatChunk.buffer).setUint32(108, 0, false); // CRC placeholder
+        // IEND chunk
+        const iendChunk = new Uint8Array([0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130]);
+        // Combine all chunks
+        const png = new Uint8Array(signature.length + ihdrChunk.length + idatChunk.length + iendChunk.length);
+        png.set(signature, 0);
+        png.set(ihdrChunk, signature.length);
+        png.set(idatChunk, signature.length + ihdrChunk.length);
+        png.set(iendChunk, signature.length + ihdrChunk.length + idatChunk.length);
+        return png;
+    }
+    it('should send chunked media with Uint8Array data', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const testData = createTestPNG(100, 100);
+        const { eventId } = await bot.sendMessage(channelId, 'Chunked media test', {
+            attachments: [
+                {
+                    type: 'chunked',
+                    data: testData,
+                    filename: 'test.png',
+                    mimetype: 'image/png',
+                    width: 100,
+                    height: 100,
+                },
+            ],
+        });
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        const message = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+        expect(message?.content?.kind).toBe(RiverTimelineEvent.ChannelMessage);
+        const attachments = message?.content?.kind === RiverTimelineEvent.ChannelMessage
+            ? message?.content?.attachments
+            : undefined;
+        expect(attachments).toHaveLength(1);
+        expect(attachments?.[0].type).toBe('chunked_media');
+        const chunkedMedia = attachments?.[0].type === 'chunked_media' ? attachments?.[0] : undefined;
+        expect(chunkedMedia).toBeDefined();
+        expect(chunkedMedia?.info.filename).toBe('test.png');
+        expect(chunkedMedia?.info.mimetype).toBe('image/png');
+        expect(chunkedMedia?.info.widthPixels).toBe(100);
+        expect(chunkedMedia?.info.heightPixels).toBe(100);
+        expect(chunkedMedia?.streamId).toBeDefined();
+        expect(chunkedMedia?.encryption).toBeDefined();
+    });
+    it('should send chunked media with Blob data and auto-detect dimensions', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const testData = createTestPNG(200, 150);
+        const blob = new Blob([testData.buffer], { type: 'image/png' });
+        const { eventId } = await bot.sendMessage(channelId, 'Blob test', {
+            attachments: [
+                {
+                    type: 'chunked',
+                    data: blob,
+                    filename: 'blob-test.png',
+                },
+            ],
+        });
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        const message = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+        const attachments = message?.content?.kind === RiverTimelineEvent.ChannelMessage
+            ? message?.content?.attachments
+            : undefined;
+        expect(attachments).toHaveLength(1);
+        const chunkedMedia = attachments?.[0].type === 'chunked_media' ? attachments?.[0] : undefined;
+        expect(chunkedMedia?.info.widthPixels).toBe(200);
+        expect(chunkedMedia?.info.heightPixels).toBe(150);
+    });
+    it('should handle large chunked media (multiple chunks)', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        // Create 2.5MB of data - will create mulitple chunks
+        const largeData = new Uint8Array(2500000);
+        for (let i = 0; i < largeData.length; i++) {
+            largeData[i] = i % 256;
+        }
+        const { eventId } = await bot.sendMessage(channelId, 'Large media test', {
+            attachments: [
+                {
+                    type: 'chunked',
+                    data: largeData,
+                    filename: 'large-file.bin',
+                    mimetype: 'application/octet-stream',
+                },
+            ],
+        });
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined(), { timeoutMS: 30000 });
+        const message = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+        const attachments = message?.content?.kind === RiverTimelineEvent.ChannelMessage
+            ? message?.content?.attachments
+            : undefined;
+        expect(attachments).toHaveLength(1);
+        const chunkedMedia = attachments?.[0].type === 'chunked_media' ? attachments?.[0] : undefined;
+        expect(chunkedMedia?.info.sizeBytes).toBe(BigInt(2500000));
+    });
+    // @miguel-nascimento 2025-12-08 flaky test
+    it.skip('should send mixed attachments (URL + chunked)', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const testData = createTestPNG(50, 50);
+        const imageUrl = 'https://placehold.co/100x100.png';
+        const { eventId } = await bot.sendMessage(channelId, 'Mixed attachments', {
+            attachments: [
+                { type: 'image', url: imageUrl },
+                {
+                    type: 'chunked',
+                    data: testData,
+                    filename: 'generated.png',
+                    mimetype: 'image/png',
+                },
+            ],
+        });
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        const message = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+        const attachments = message?.content?.kind === RiverTimelineEvent.ChannelMessage
+            ? message?.content?.attachments
+            : undefined;
+        expect(attachments).toHaveLength(2);
+        expect(attachments?.[0].type).toBe('image');
+        expect(attachments?.[1].type).toBe('chunked_media');
+    });
+    it('should send and receive GM messages with schema validation', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const messageSchema = z.object({ text: z.string(), count: z.number() });
+        const receivedGmEvents = [];
+        subscriptions.push(bot.onGmMessage('test.typed.v1', messageSchema, (_h, e) => {
+            receivedGmEvents.push({ typeUrl: e.typeUrl, data: e.data });
+        }));
+        const testData = { text: 'Hello', count: 42 };
+        // Bob sends the message so bot receives it (bot filters its own messages)
+        const jsonString = superjsonStringify(testData);
+        await bobClient.riverConnection.call((client) => client.sendChannelMessage_GM(channelId, {
+            content: {
+                typeUrl: 'test.typed.v1',
+                value: new TextEncoder().encode(jsonString),
+            },
+        }));
+        await waitFor(() => receivedGmEvents.length > 0);
+        const event = receivedGmEvents[0];
+        expect(event).toBeDefined();
+        expect(event.typeUrl).toBe('test.typed.v1');
+        expect(event.data).toEqual(testData);
+    });
+    it('should handle GM with Date objects (superjson serialization)', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const eventSchema = z.object({
+            eventType: z.string(),
+            timestamp: z.date(),
+        });
+        const testDate = new Date('2025-01-15T12:00:00Z');
+        const { eventId } = await bot.sendGM(channelId, 'test.date.v1', eventSchema, {
+            eventType: 'test',
+            timestamp: testDate,
+        });
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        const message = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+        expect(message?.content?.kind).toBe(RiverTimelineEvent.ChannelMessage);
+        const gmData = message?.content?.kind === RiverTimelineEvent.ChannelMessage &&
+            message?.content?.content.msgType === MessageType.GM
+            ? message?.content?.content.data
+            : undefined;
+        expect(gmData).toBeDefined();
+        expect(gmData).toStrictEqual(new TextEncoder().encode(superjsonStringify({ eventType: 'test', timestamp: testDate })));
+    });
+    it('should handle multiple handlers for different typeUrls', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const schema1 = z.object({ type: z.literal('type1'), value: z.number() });
+        const schema2 = z.object({ type: z.literal('type2'), text: z.string() });
+        const receivedType1 = [];
+        const receivedType2 = [];
+        subscriptions.push(bot.onGmMessage('test.multi.type1', schema1, (_h, e) => {
+            receivedType1.push(e.data);
+        }));
+        subscriptions.push(bot.onGmMessage('test.multi.type2', schema2, (_h, e) => {
+            receivedType2.push(e.data);
+        }));
+        const data1 = { type: 'type1', value: 123 };
+        const data2 = { type: 'type2', text: 'hello' };
+        await bobClient.riverConnection.call((client) => client.sendChannelMessage_GM(channelId, {
+            content: {
+                typeUrl: 'test.multi.type1',
+                value: new TextEncoder().encode(superjsonStringify(data1)),
+            },
+        }));
+        await bobClient.riverConnection.call((client) => client.sendChannelMessage_GM(channelId, {
+            content: {
+                typeUrl: 'test.multi.type2',
+                value: new TextEncoder().encode(superjsonStringify(data2)),
+            },
+        }));
+        await waitFor(() => receivedType1.length > 0 && receivedType2.length > 0);
+        expect(receivedType1[0]).toEqual(data1);
+        expect(receivedType2[0]).toEqual(data2);
+    });
+    it('should handle raw GM messages', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedMessages = [];
+        subscriptions.push(bot.onRawGmMessage((_h, e) => {
+            receivedMessages.push({ typeUrl: e.typeUrl, message: e.message });
+        }));
+        const message = new TextEncoder().encode('Hello, world!');
+        await bobClient.riverConnection.call((client) => client.sendChannelMessage_GM(channelId, {
+            content: {
+                typeUrl: 'test.raw.v1',
+                value: message,
+            },
+        }));
+        await waitFor(() => receivedMessages.length > 0);
+        expect(receivedMessages[0].typeUrl).toBe('test.raw.v1');
+        expect(receivedMessages[0].message).toEqual(message);
+    });
+    it('should log error and continue processing if throws an error when handling an event', async () => {
+        const consoleErrorSpy = vi.spyOn(console, 'error');
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        subscriptions.push(bot.onMessage(() => {
+            throw new Error('test error');
+        }));
+        await bobDefaultGdm.sendMessage('lol');
+        await waitFor(() => consoleErrorSpy.mock.calls.length > 0);
+        expect(consoleErrorSpy.mock.calls[0][0]).toContain('[@towns-labs/agent] Error while handling event');
+        consoleErrorSpy.mockRestore();
+    });
+    it('bot should be able to send encrypted interaction request and user should send encrypted response', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_MENTIONS_REPLIES_REACTIONS);
+        const requestId = randomUUID();
+        const interactionRequestContent = {
+            case: 'signature',
+            value: {
+                id: requestId,
+                data: '0x1234567890',
+                chainId: '1',
+                type: InteractionRequestPayload_Signature_SignatureType.PERSONAL_SIGN,
+            },
+        };
+        const { eventId } = await bot.sendInteractionRequest(channelId, interactionRequestContent);
+        // Wait for Bob to receive the interaction request
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        // Wait for decryption to complete
+        await waitFor(() => {
+            const event = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+            if (event?.content?.kind !== RiverTimelineEvent.InteractionRequest) {
+                return false;
+            }
+            return event?.content?.payload !== undefined;
+        });
+        const decryptedEvent = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+        expect(decryptedEvent?.content?.kind).toBe(RiverTimelineEvent.InteractionRequest);
+        if (decryptedEvent?.content?.kind !== RiverTimelineEvent.InteractionRequest) {
+            throw new Error('Event is not an InteractionRequest');
+        }
+        const decryptedPayload = decryptedEvent.content.payload;
+        const encryptionDevice = decryptedPayload?.encryptionDevice;
+        expect(decryptedPayload).toBeDefined();
+        expect(encryptionDevice).toBeDefined();
+        expect(decryptedPayload?.content.case).toBe('signature');
+        if (decryptedPayload?.content.case === 'signature') {
+            expect(decryptedPayload.content.value.id).toBe(requestId);
+            expect(decryptedPayload.content.value.data).toBe('0x1234567890');
+        }
+        // bob should be able to send interaction response to the bot using the decrypted encryption device
+        const recipient = bin_fromHexString(botClientAddress);
+        const interactionResponsePayload = {
+            salt: genIdBlob(),
+            content: {
+                case: 'signature',
+                value: {
+                    requestId: requestId,
+                    signature: '0x123222222222',
+                },
+            },
+        };
+        const receivedInteractionResponses = [];
+        subscriptions.push(bot.onInteractionResponse((_h, e) => {
+            receivedInteractionResponses.push(e.response);
+        }));
+        await bobClient.riverConnection.call(async (client) => {
+            // from the client, to the channel, encrypted so that only the bot can read it
+            return await client.sendInteractionResponse(channelId, recipient, interactionResponsePayload, encryptionDevice);
+        });
+        await waitFor(() => receivedInteractionResponses.length > 0);
+        expect(receivedInteractionResponses[0].recipient).toEqual(recipient);
+        expect(receivedInteractionResponses[0].payload.content.value?.requestId).toEqual(requestId);
+    });
+    it('user should NOT be able to send interaction request', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const interactionRequestContent = {
+            case: 'signature',
+            value: {
+                id: randomUUID(),
+                data: '0x1234567890',
+                chainId: '1',
+                type: InteractionRequestPayload_Signature_SignatureType.PERSONAL_SIGN,
+            },
+        };
+        await bobClient.riverConnection.call(async (client) => {
+            // Try to send an interaction request as a user (should fail)
+            // Note: Even if we try to use the proper sendInteractionRequest method,
+            // it should fail because only apps can send interaction requests
+            await expect(client.sendInteractionRequest(channelId, interactionRequestContent)).rejects.toThrow(/creator is not an app/);
+        });
+    });
+    it('bot should be able to send form interaction request', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const interactionRequestContent = {
+            case: 'form',
+            value: {
+                id: randomUUID(),
+                components: [
+                    { id: '1', component: { case: 'button', value: { label: 'Button' } } },
+                    {
+                        id: '2',
+                        component: { case: 'textInput', value: { placeholder: 'Text Input' } },
+                    },
+                ],
+            },
+        };
+        const { eventId } = await bot.sendInteractionRequest(channelId, interactionRequestContent);
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        const message = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+        expect(message).toBeDefined();
+    });
+    it('bot should be able to send signature interaction request using flattened API', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const requestId = randomUUID();
+        const { eventId } = await bot.sendInteractionRequest(channelId, {
+            type: 'signature',
+            id: requestId,
+            data: '0xabcdef1234567890',
+            chainId: '8453',
+            method: 'personal_sign',
+            signerWallet: botClientAddress,
+        });
+        // Wait for Bob to receive the interaction request
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        // Wait for decryption to complete
+        await waitFor(() => {
+            const event = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+            if (event?.content?.kind !== RiverTimelineEvent.InteractionRequest) {
+                return false;
+            }
+            return event?.content?.payload !== undefined;
+        });
+        const decryptedEvent = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+        expect(decryptedEvent?.content?.kind).toBe(RiverTimelineEvent.InteractionRequest);
+        if (decryptedEvent?.content?.kind !== RiverTimelineEvent.InteractionRequest) {
+            throw new Error('Event is not an InteractionRequest');
+        }
+        const decryptedPayload = decryptedEvent.content.payload;
+        expect(decryptedPayload).toBeDefined();
+        expect(decryptedPayload?.content.case).toBe('signature');
+        if (decryptedPayload?.content.case === 'signature') {
+            expect(decryptedPayload.content.value.id).toBe(requestId);
+            expect(decryptedPayload.content.value.data).toBe('0xabcdef1234567890');
+            expect(decryptedPayload.content.value.chainId).toBe('8453');
+            expect(decryptedPayload.content.value.type).toBe(InteractionRequestPayload_Signature_SignatureType.PERSONAL_SIGN);
+        }
+    });
+    it('bot should be able to send form interaction request using flattened API', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const requestId = randomUUID();
+        const { eventId } = await bot.sendInteractionRequest(channelId, {
+            type: 'form',
+            id: requestId,
+            components: [
+                { id: 'btn-1', type: 'button', label: 'Click Me' },
+                { id: 'input-1', type: 'textInput', placeholder: 'Enter text here' },
+            ],
+        });
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        // Wait for decryption to complete
+        await waitFor(() => {
+            const event = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+            if (event?.content?.kind !== RiverTimelineEvent.InteractionRequest) {
+                return false;
+            }
+            return event?.content?.payload !== undefined;
+        });
+        const decryptedEvent = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+        expect(decryptedEvent?.content?.kind).toBe(RiverTimelineEvent.InteractionRequest);
+        if (decryptedEvent?.content?.kind !== RiverTimelineEvent.InteractionRequest) {
+            throw new Error('Event is not an InteractionRequest');
+        }
+        const decryptedPayload = decryptedEvent.content.payload;
+        expect(decryptedPayload).toBeDefined();
+        expect(decryptedPayload?.content.case).toBe('form');
+        if (decryptedPayload?.content.case === 'form') {
+            expect(decryptedPayload.content.value.id).toBe(requestId);
+            expect(decryptedPayload.content.value.components).toHaveLength(2);
+            expect(decryptedPayload.content.value.components[0].id).toBe('btn-1');
+            expect(decryptedPayload.content.value.components[0].component.case).toBe('button');
+            expect(decryptedPayload.content.value.components[1].id).toBe('input-1');
+            expect(decryptedPayload.content.value.components[1].component.case).toBe('textInput');
+        }
+    });
+    it('bot should be able to send transaction interaction request using flattened API', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const requestId = randomUUID();
+        const { eventId } = await bot.sendInteractionRequest(channelId, {
+            type: 'transaction',
+            id: requestId,
+            title: 'Send USDC',
+            subtitle: 'Send 50 USDC to recipient',
+            tx: {
+                chainId: '8453',
+                to: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
+                value: '0',
+                data: '0xa9059cbb', // transfer function selector
+                signerWallet: botClientAddress,
+            },
+        });
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        // Wait for decryption to complete
+        await waitFor(() => {
+            const event = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+            if (event?.content?.kind !== RiverTimelineEvent.InteractionRequest) {
+                return false;
+            }
+            return event?.content?.payload !== undefined;
+        });
+        const decryptedEvent = bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId);
+        expect(decryptedEvent?.content?.kind).toBe(RiverTimelineEvent.InteractionRequest);
+        if (decryptedEvent?.content?.kind !== RiverTimelineEvent.InteractionRequest) {
+            throw new Error('Event is not an InteractionRequest');
+        }
+        const decryptedPayload = decryptedEvent.content.payload;
+        expect(decryptedPayload).toBeDefined();
+        expect(decryptedPayload?.content.case).toBe('transaction');
+        if (decryptedPayload?.content.case === 'transaction') {
+            expect(decryptedPayload.content.value.id).toBe(requestId);
+            expect(decryptedPayload.content.value.title).toBe('Send USDC');
+            expect(decryptedPayload.content.value.subtitle).toBe('Send 50 USDC to recipient');
+            expect(decryptedPayload.content.value.content.case).toBe('evm');
+            if (decryptedPayload.content.value.content.case === 'evm') {
+                expect(decryptedPayload.content.value.content.value.chainId).toBe('8453');
+                expect(decryptedPayload.content.value.content.value.to).toBe('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913');
+                expect(decryptedPayload.content.value.content.value.value).toBe('0');
+                expect(decryptedPayload.content.value.content.value.data).toBe('0xa9059cbb');
+            }
+        }
+    });
+    it('bot should be able to send addMember interaction request and user should respond', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        // Create a new GDM with bob, carol, and the bot (alice is NOT in it)
+        const { streamId: addMemberGdmId } = await bobClient.gdms.createGDM([
+            { userId: carol.userId },
+            { userId: bot.agentUserId, appAddress: bot.appAddress },
+        ]);
+        await bobClient.riverConnection.call((client) => client.waitForStream(addMemberGdmId));
+        const bobAddMemberGdm = bobClient.gdms.getGdm(addMemberGdmId);
+        const requestId = randomUUID();
+        // Bot sends addMember interaction request to bob
+        const { eventId } = await bot.sendInteractionRequest(addMemberGdmId, {
+            type: 'addMember',
+            id: requestId,
+            userId: alice.userId,
+            message: 'Please add Alice to the group, she has great intel!',
+        });
+        // Wait for Bob to receive the interaction request
+        await waitFor(() => expect(bobAddMemberGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        // Wait for decryption to complete
+        await waitFor(() => {
+            const event = bobAddMemberGdm.timeline.events.value.find((x) => x.eventId === eventId);
+            if (event?.content?.kind !== RiverTimelineEvent.InteractionRequest) {
+                return false;
+            }
+            return event?.content?.payload !== undefined;
+        });
+        // Bob decrypts the request and verifies
+        const decryptedEvent = bobAddMemberGdm.timeline.events.value.find((x) => x.eventId === eventId);
+        expect(decryptedEvent?.content?.kind).toBe(RiverTimelineEvent.InteractionRequest);
+        if (decryptedEvent?.content?.kind !== RiverTimelineEvent.InteractionRequest) {
+            throw new Error('Event is not an InteractionRequest');
+        }
+        const decryptedPayload = decryptedEvent.content.payload;
+        expect(decryptedPayload).toBeDefined();
+        expect(decryptedPayload?.content.case).toBe('addMember');
+        if (decryptedPayload?.content.case === 'addMember') {
+            expect(decryptedPayload.content.value.id).toBe(requestId);
+            expect(decryptedPayload.content.value.userId).toEqual(bin_fromHexString(alice.userId));
+            expect(decryptedPayload.content.value.message).toBe('Please add Alice to the group, she has great intel!');
+        }
+        const encryptionDevice = decryptedPayload?.encryptionDevice;
+        expect(encryptionDevice).toBeDefined();
+        expect(encryptionDevice?.deviceKey).toBeDefined();
+        expect(encryptionDevice?.fallbackKey).toBeDefined();
+        // Bob sends addMember interaction response with accepted: true
+        const recipient = bin_fromHexString(botClientAddress);
+        const interactionResponsePayload = {
+            salt: genIdBlob(),
+            content: {
+                case: 'addMember',
+                value: {
+                    requestId: requestId,
+                    accepted: true,
+                },
+            },
+        };
+        const receivedInteractionResponses = [];
+        subscriptions.push(bot.onInteractionResponse((_h, e) => {
+            receivedInteractionResponses.push(e.response);
+        }));
+        // Bob calls joinUser() to add alice to the GDM
+        await bobClient.riverConnection.call((client) => client.joinUser(addMemberGdmId, alice.userId));
+        await bobClient.riverConnection.call(async (client) => {
+            return await client.sendInteractionResponse(addMemberGdmId, recipient, interactionResponsePayload, encryptionDevice);
+        });
+        // Bot receives the response and verifies
+        await waitFor(() => receivedInteractionResponses.length > 0);
+        expect(receivedInteractionResponses[0].recipient).toEqual(recipient);
+        expect(receivedInteractionResponses[0].payload.content.case).toBe('addMember');
+        if (receivedInteractionResponses[0].payload.content.case === 'addMember') {
+            expect(receivedInteractionResponses[0].payload.content.value.requestId).toBe(requestId);
+            expect(receivedInteractionResponses[0].payload.content.value.accepted).toBe(true);
+        }
+        // Verify alice is now a member of the GDM
+        await waitFor(() => {
+            expect(bobAddMemberGdm.members.data.userIds).toContain(alice.userId);
+        });
+    });
+    it('user should be able to send form interaction response', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_MENTIONS_REPLIES_REACTIONS);
+        const recipient = bin_fromHexString(botClientAddress);
+        const interactionResponsePayload = {
+            salt: genIdBlob(),
+            content: {
+                case: 'form',
+                value: {
+                    requestId: randomUUID(),
+                    components: [
+                        { id: '1', component: { case: 'button', value: {} } },
+                        {
+                            id: '2',
+                            component: { case: 'textInput', value: { value: 'Text Input' } },
+                        },
+                    ],
+                },
+            },
+        };
+        const receivedInteractionResponses = [];
+        subscriptions.push(bot.onInteractionResponse((_h, e) => {
+            receivedInteractionResponses.push(e.response);
+        }));
+        await bobClient.riverConnection.call(async (client) => {
+            return await client.sendInteractionResponse(channelId, recipient, interactionResponsePayload, bot.getUserDevice());
+        });
+        await waitFor(() => receivedInteractionResponses.length > 0);
+    });
+    it('bot should be able to pin and unpin their own messages', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const { eventId, envelope } = await bot.sendMessage(channelId, 'Hello');
+        const parsedEvnet = await bot.client.unpackEnvelope(envelope);
+        const { eventId: pinEventId } = await bot.pinMessage(channelId, eventId, parsedEvnet.event);
+        log('pinned event', pinEventId);
+        const { eventId: unpinEventId } = await bot.unpinMessage(channelId, eventId);
+        log('unpinned event', unpinEventId);
+    });
+    // @miguel-nascimento 2025-12-08 flaky test
+    it.skip('bot should be able to pin and unpin other users messages', async () => {
+        // Skipped: marked flaky in prior runs.
+        /*
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES)
+        const { eventId } = await bobDefaultGdm.sendMessage('Hello')
+        const receivedMessages: OnMessageType[] = []
+        subscriptions.push(
+            bot.onMessage((_h, e) => {
+                receivedMessages.push(e)
+            }),
+        )
+        await waitFor(() => receivedMessages.length > 0)
+        const message = receivedMessages.find((x) => x.eventId === eventId)
+        check(isDefined(message), 'message is defined')
+        expect(message).toBeDefined()
+        expect(message?.event).toBeDefined()
+
+        const { eventId: pinEventId } = await bot.pinMessage(channelId, eventId, message.event)
+        log('pinned event', pinEventId)
+        const { eventId: unpinEventId } = await bot.unpinMessage(channelId, eventId)
+        log('unpinned event', unpinEventId)
+        */
+    });
+    it('bob (bot owner) should be able to update bot profile image', async () => {
+        // Create mock chunked media info (following pattern from client.test.ts:1010-1047)
+        const mediaStreamId = makeUniqueMediaStreamId();
+        const image = create(MediaInfoSchema, {
+            mimetype: 'image/png',
+            filename: 'bot-avatar.png',
+        });
+        const { key, iv } = await deriveKeyAndIV(nanoid(128));
+        const chunkedMediaInfo = {
+            info: image,
+            streamId: mediaStreamId,
+            encryption: {
+                case: 'aesgcm',
+                value: { secretKey: key, iv },
+            },
+            thumbnail: undefined,
+        };
+        // Bob (bot owner) updates the bot's profile image using setUserProfileImageFor
+        await bobClient.riverConnection.call(async (client) => {
+            await client.setUserProfileImage(chunkedMediaInfo, botClientAddress);
+        });
+        await waitFor(async () => {
+            // Verify the bot's profile image was updated
+            // in waitFor because sometimes it takes a second before you can getStream on a media stream
+            const decrypted = await bobClient.riverConnection.call(async (client) => {
+                return await client.getUserProfileImage(botClientAddress);
+            });
+            expect(decrypted).toBeDefined();
+            expect(decrypted?.info?.mimetype).toBe('image/png');
+            expect(decrypted?.info?.filename).toBe('bot-avatar.png');
+        });
+    });
+    it('agent should receive messages from another agent', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        // Get contract addresses for this environment
+        const chainId = townsConfig.base.chainConfig.chainId;
+        const addresses = getAddressesWithFallback(townsConfig.environmentId, chainId);
+        if (!addresses?.accountProxy) {
+            throw new Error(`No accountProxy address found for ${townsConfig.environmentId}/${chainId}`);
+        }
+        // Create relayer client for agent2
+        const relayerUrl = process.env.RELAYER_URL ?? 'http://127.0.0.1:8787';
+        const relayerClient = createPublicClient({
+            chain: {
+                id: chainId,
+                name: 'Test Chain',
+                nativeCurrency: { name: 'Ether', symbol: 'ETH', decimals: 18 },
+                rpcUrls: { default: { http: [townsConfig.base.rpcUrl] } },
+            },
+            transport: http(townsConfig.base.rpcUrl),
+        }).extend(relayerActions({ relayerUrl }));
+        // Create agent2 using relayer
+        const agent2Result = await createApp({
+            owner: bobClient.riverConnection.signerContext,
+            metadata: {
+                username: `agent2-${randomUUID()}`,
+                displayName: 'Agent 2',
+                description: 'Second test agent',
+                imageUrl: 'https://placehold.co/600x600',
+            },
+            relayerClient,
+            accountProxy: addresses.accountProxy,
+            townsConfig,
+        });
+        const agent2Address = agent2Result.appAddress;
+        // Join agent2 to the channel
+        await bobClient.riverConnection.call((client) => client.joinUser(channelId, agent2Address));
+        // Set forward setting for agent2 (registration already done by createApp)
+        await appRegistryRpcClient.setAppSettings({
+            appId: bin_fromHexString(agent2Address),
+            settings: { forwardSetting: ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES },
+        });
+        const agent2 = await makeTownsAgent(agent2Result.appPrivateData, agent2Result.jwtSecretBase64, {
+            commands: [],
+        });
+        // Start agent2 server on a different port
+        const agent2Port = Number(process.env.BOT_PORT) + 1;
+        const agent2WebhookUrl = `https://localhost:${agent2Port}/webhook`;
+        const app2 = agent2.start();
+        serve({
+            port: agent2Port,
+            fetch: app2.fetch,
+            createServer,
+        });
+        await appRegistryRpcClient.registerWebhook({
+            appId: bin_fromHexString(agent2Address),
+            webhookUrl: agent2WebhookUrl,
+        });
+        // Subscribe to messages on agent2
+        const receivedByAgent2 = [];
+        subscriptions.push(agent2.onMessage((_h, e) => {
+            receivedByAgent2.push(e);
+        }));
+        // Agent1 sends a message mentioning Agent2
+        const testMessage = 'Hey @agent2, can you help with this?';
+        const { eventId } = await bot.sendMessage(channelId, testMessage, {
+            mentions: [
+                {
+                    userId: agent2Address,
+                    displayName: 'Agent 2',
+                },
+            ],
+        });
+        // Verify Agent2 received the message from Agent1
+        await waitFor(() => receivedByAgent2.length > 0, { timeoutMS: 15_000 });
+        const receivedMessage = receivedByAgent2.find((x) => x.eventId === eventId);
+        expect(receivedMessage).toBeDefined();
+        expect(receivedMessage?.message).toBe(testMessage);
+        expect(receivedMessage?.userId).toBe(botClientAddress); // Sent by agent1
+        expect(receivedMessage?.isMentioned).toBe(true); // Agent2 was mentioned
+    });
+});
+//# sourceMappingURL=agent.test.js.map