@towns-labs/app-framework 4.0.0

package/dist/app.test.js

@@ -0,0 +1,2070 @@
+import { makeBaseProvider, makeUserStreamId, townsEnv, RiverTimelineEvent, Bot as SyncAgentTest, AppRegistryService, MessageType, genIdBlob, makeUniqueMediaStreamId, createApp, streamIdAsBytes, isDefined, genId, } from '@towns-labs/sdk';
+import { waitFor } from '@towns-labs/sdk/src/tests/testUtils';
+import { describe, it, expect, beforeAll, afterEach, vi } from 'vitest';
+import { bin_fromHexString, check, dlog } from '@towns-labs/utils';
+import { makeTownsApp } from './app';
+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, InteractionRequestPayload_PreparedCalls_Permission_Type, MediaInfoSchema, PositionType, SupportedApi, } from '@towns-labs/proto';
+import { ETH_ADDRESS } from '@towns-labs/web3';
+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 = `http://localhost:${process.env.BOT_PORT}/webhook`;
+const SLASH_COMMANDS = [
+    { name: 'help', description: 'Get help with bot commands' },
+    { name: 'status', description: 'Check bot status' },
+    { name: 'set_positions', description: 'Set positions for the caller' },
+];
+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 = `witness_${genId(8)}`;
+    const BOT_DISPLAY_NAME = 'Uber Test Bot';
+    const BOT_DESCRIPTION = 'I shall witness everything';
+    const bob_username = `bob_${genId(12)}`; // unique across multiple non-concurrent runs
+    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 appRegistryRpcClient.setUserName({
+            username: bob_username,
+            displayName: 'Bob Display',
+        });
+        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) => {
+        const appId = bin_fromHexString(botClientAddress);
+        await appRegistryRpcClient.updateAppSettings({
+            appId,
+            forwardSetting,
+            updateMask: ['forward_setting'],
+        });
+    };
+    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([alice.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 result = await createAppForOwner(bobClient, {
+            username: BOT_USERNAME,
+            displayName: BOT_DISPLAY_NAME,
+            description: BOT_DESCRIPTION,
+            imageUrl: 'https://placehold.co/600x600',
+            slashCommands: SLASH_COMMANDS,
+        });
+        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 createAppForOwner = async (ownerClient, metadata) => {
+        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 }));
+        return createApp({
+            owner: ownerClient.riverConnection.signerContext,
+            metadata,
+            relayerClient,
+            accountProxy: addresses.accountProxy,
+            townsConfig,
+        });
+    };
+    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 makeTownsApp(appPrivateData, {
+            jwtSecret: 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,
+        });
+        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('should store positions from /set_positions and return them via onPositions', async () => {
+        // regression test, userIds were cased differently in events vs over the positions webhook request
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        await appRegistryRpcClient.updateAppSettings({
+            appId: bin_fromHexString(botClientAddress),
+            supportedApis: [SupportedApi.POSITIONS],
+            updateMask: ['supported_apis'],
+        });
+        const positionsByUserId = new Map();
+        let slashCommandUserId;
+        let onPositionsUserId;
+        subscriptions.push(bot.onSlashCommand('set_positions', (_h, e) => {
+            const value = e.args[0];
+            if (!value) {
+                return;
+            }
+            slashCommandUserId = e.userId;
+            positionsByUserId.set(e.userId, value);
+        }));
+        subscriptions.push(bot.onPositions((_h, e) => {
+            onPositionsUserId = e.userId;
+            const balanceUsd = positionsByUserId.get(e.userId);
+            return {
+                supported: true,
+                positions: balanceUsd
+                    ? [
+                        {
+                            label: 'Stored Position',
+                            symbol: 'TEST',
+                            type: PositionType.PERPETUAL,
+                            balanceUsd,
+                            pnlUsd: '0',
+                        },
+                    ]
+                    : [],
+                timestamp: BigInt(Date.now()),
+            };
+        }));
+        const storedBalanceUsd = '123.45';
+        await bobDefaultGdm.sendMessage(`/set_positions ${storedBalanceUsd}`, {
+            appClientAddress: bot.agentUserId,
+        });
+        await waitFor(() => positionsByUserId.size > 0);
+        const positionsResp = await appRegistryRpcClient.getAppPositions({
+            appId: bin_fromHexString(botClientAddress),
+        });
+        expect(positionsResp.positions?.supported).toBe(true);
+        expect(positionsResp.positions?.positions).toHaveLength(1);
+        expect(positionsResp.positions?.positions[0]?.balanceUsd).toBe(storedBalanceUsd);
+        expect(slashCommandUserId).toBeDefined();
+        expect(onPositionsUserId).toBeDefined();
+        expect(onPositionsUserId).toBe(slashCommandUserId);
+    });
+    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.getUser returns entity name set via app registry', async () => {
+        const userInfo = await bot.getUser(bob.userId);
+        expect(userInfo).toBeDefined();
+        expect(userInfo.username).toBe(bob_username);
+        expect(userInfo.displayName).toBe('Bob Display');
+    });
+    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.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([alice.userId, bot.agentUserId]);
+        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/app-framework] 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 { eventId, requestId } = await bot.sendInteractionRequest(channelId, {
+            type: 'signature',
+            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 { eventId, requestId } = await bot.sendInteractionRequest(channelId, {
+            type: 'form',
+            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 { eventId, requestId } = await bot.sendInteractionRequest(channelId, {
+            type: 'transaction',
+            title: 'Send USDC',
+            subtitle: 'Send 50 USDC to recipient',
+            chainId: '8453',
+            signerWallet: botClientAddress,
+            txs: [
+                {
+                    to: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
+                    value: '0',
+                    data: '0xa9059cbb', // transfer function selector
+                },
+            ],
+        });
+        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') {
+                const evmBatch = decryptedPayload.content.value.content.value;
+                expect(evmBatch.chainId).toBe('8453');
+                expect(evmBatch.transactions).toHaveLength(1);
+                expect(evmBatch.transactions[0].to).toBe('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913');
+                expect(evmBatch.transactions[0].value).toBe('0');
+                expect(evmBatch.transactions[0].data).toBe('0xa9059cbb');
+            }
+        }
+    });
+    it('bot should be able to send batched transaction interaction request', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const { eventId, requestId } = await bot.sendInteractionRequest(channelId, {
+            type: 'transaction',
+            title: 'Batch Transaction',
+            subtitle: 'Approve and transfer USDC',
+            chainId: '8453',
+            signerWallet: botClientAddress,
+            txs: [
+                {
+                    to: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
+                    value: '0',
+                    data: '0x095ea7b3', // approve function selector
+                },
+                {
+                    to: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
+                    value: '0',
+                    data: '0xa9059cbb', // transfer function selector
+                },
+            ],
+        });
+        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('Batch Transaction');
+            expect(decryptedPayload.content.value.content.case).toBe('evm');
+            if (decryptedPayload.content.value.content.case === 'evm') {
+                const evmBatch = decryptedPayload.content.value.content.value;
+                expect(evmBatch.chainId).toBe('8453');
+                expect(evmBatch.signerWallet).toBe(botClientAddress);
+                expect(evmBatch.transactions).toHaveLength(2);
+                // First tx: approve
+                expect(evmBatch.transactions[0].to).toBe('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913');
+                expect(evmBatch.transactions[0].data).toBe('0x095ea7b3');
+                // Second tx: transfer
+                expect(evmBatch.transactions[1].to).toBe('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913');
+                expect(evmBatch.transactions[1].data).toBe('0xa9059cbb');
+            }
+        }
+    });
+    it('bot should be able to send preparedCalls interaction request using flattened API', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const { eventId, requestId } = await bot.sendInteractionRequest(channelId, {
+            type: 'preparedCalls',
+            chainId: '8453',
+            typedData: '{"types":{"EIP712Domain":[]},"primaryType":"EIP712Domain","domain":{},"message":{}}',
+            context: '{"some":"context"}',
+            title: 'Approve Token Spend',
+            subtitle: 'Allow the app to spend up to 100 USDC',
+            authorizeKeys: [
+                {
+                    expiry: '1700000000',
+                    type: 'secp256k1',
+                    role: 'normal',
+                    publicKey: '0x04abcdef',
+                    permissions: [
+                        {
+                            type: 'spend',
+                            token: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+                            limit: '100000000',
+                            period: '86400',
+                        },
+                    ],
+                },
+            ],
+        });
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        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('preparedCalls');
+        if (decryptedPayload?.content.case === 'preparedCalls') {
+            expect(decryptedPayload.content.value.id).toBe(requestId);
+            expect(decryptedPayload.content.value.chainId).toBe('8453');
+            expect(decryptedPayload.content.value.typedData).toBe('{"types":{"EIP712Domain":[]},"primaryType":"EIP712Domain","domain":{},"message":{}}');
+            expect(decryptedPayload.content.value.context).toBe('{"some":"context"}');
+            expect(decryptedPayload.content.value.title).toBe('Approve Token Spend');
+            expect(decryptedPayload.content.value.subtitle).toBe('Allow the app to spend up to 100 USDC');
+            expect(decryptedPayload.content.value.authorizeKeys).toHaveLength(1);
+            const key = decryptedPayload.content.value.authorizeKeys[0];
+            expect(key.expiry).toBe('1700000000');
+            expect(key.type).toBe('secp256k1');
+            expect(key.role).toBe('normal');
+            expect(key.publicKey).toBe('0x04abcdef');
+            expect(key.permissions).toHaveLength(1);
+            expect(key.permissions[0].type).toBe(InteractionRequestPayload_PreparedCalls_Permission_Type.SPEND);
+            expect(key.permissions[0].permission.case).toBe('spend');
+            if (key.permissions[0].permission.case === 'spend') {
+                expect(key.permissions[0].permission.value.token).toBe('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913');
+                expect(key.permissions[0].permission.value.limit).toBe('100000000');
+                expect(key.permissions[0].permission.value.period).toBe('86400');
+            }
+        }
+    });
+    it('bot should be able to send preparedCalls with authorizeKeys', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const { eventId } = await bot.sendInteractionRequest(channelId, {
+            type: 'preparedCalls',
+            chainId: '8453',
+            typedData: '{"types":{},"primaryType":"","domain":{},"message":{}}',
+            context: '{}',
+            title: 'Authorize Session Key',
+            authorizeKeys: [
+                {
+                    expiry: '1700000000',
+                    type: 'secp256k1',
+                    role: 'normal',
+                    publicKey: '0x04abcdef',
+                    permissions: [
+                        {
+                            type: 'call',
+                            to: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+                            selector: '0xa9059cbb',
+                        },
+                        {
+                            type: 'spend',
+                            token: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
+                            limit: '1000000',
+                            period: 'day',
+                        },
+                    ],
+                },
+            ],
+        });
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        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('preparedCalls');
+        if (decryptedPayload?.content.case === 'preparedCalls') {
+            expect(decryptedPayload.content.value.authorizeKeys).toHaveLength(1);
+            const key = decryptedPayload.content.value.authorizeKeys[0];
+            expect(key.expiry).toBe('1700000000');
+            expect(key.type).toBe('secp256k1');
+            expect(key.role).toBe('normal');
+            expect(key.publicKey).toBe('0x04abcdef');
+            expect(key.permissions).toHaveLength(2);
+            expect(key.permissions[0].type).toBe(InteractionRequestPayload_PreparedCalls_Permission_Type.CALL);
+            expect(key.permissions[0].permission.case).toBe('call');
+            if (key.permissions[0].permission.case === 'call') {
+                expect(key.permissions[0].permission.value.to).toBe('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913');
+                expect(key.permissions[0].permission.value.selector).toBe('0xa9059cbb');
+            }
+            expect(key.permissions[1].type).toBe(InteractionRequestPayload_PreparedCalls_Permission_Type.SPEND);
+            expect(key.permissions[1].permission.case).toBe('spend');
+            if (key.permissions[1].permission.case === 'spend') {
+                expect(key.permissions[1].permission.value.token).toBe('0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913');
+                expect(key.permissions[1].permission.value.limit).toBe('1000000');
+                expect(key.permissions[1].permission.value.period).toBe('day');
+            }
+        }
+    });
+    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([
+            carol.userId,
+            bot.agentUserId,
+        ]);
+        await bobClient.riverConnection.call((client) => client.waitForStream(addMemberGdmId));
+        const bobAddMemberGdm = bobClient.gdms.getGdm(addMemberGdmId);
+        // Bot sends addMember interaction request to bob
+        const { eventId, requestId } = await bot.sendInteractionRequest(addMemberGdmId, {
+            type: 'addMember',
+            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;
+        check(isDefined(encryptionDevice), 'encryptionDevice is defined');
+        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.value.userIds).toContain(alice.userId);
+        });
+    });
+    it('bot should be able to send batch interaction request with mixed steps using flattened API', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const { eventId, requestId: batchId } = await bot.sendInteractionRequest(channelId, {
+            type: 'batch',
+            title: 'Cross-chain Swap',
+            subtitle: 'Approve on Base, swap on Mainnet, confirm signature',
+            steps: [
+                {
+                    type: 'preparedCalls',
+                    chainId: '8453',
+                    typedData: '{"types":{"EIP712Domain":[]},"primaryType":"EIP712Domain","domain":{},"message":{}}',
+                    context: '{"step":"approve"}',
+                    title: 'Approve USDC on Base',
+                },
+                {
+                    type: 'preparedCalls',
+                    chainId: '1',
+                    typedData: '{"types":{"EIP712Domain":[]},"primaryType":"EIP712Domain","domain":{},"message":{}}',
+                    context: '{"step":"swap"}',
+                    title: 'Swap on Mainnet',
+                },
+                {
+                    type: 'signature',
+                    data: '0xdeadbeef',
+                    chainId: '1',
+                    method: 'typed_data',
+                    signerWallet: botClientAddress,
+                    title: 'Confirm swap',
+                },
+            ],
+        });
+        await waitFor(() => expect(bobDefaultGdm.timeline.events.value.find((x) => x.eventId === eventId)).toBeDefined());
+        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('batch');
+        if (decryptedPayload?.content.case === 'batch') {
+            expect(decryptedPayload.content.value.id).toBe(batchId);
+            expect(decryptedPayload.content.value.title).toBe('Cross-chain Swap');
+            expect(decryptedPayload.content.value.subtitle).toBe('Approve on Base, swap on Mainnet, confirm signature');
+            expect(decryptedPayload.content.value.steps).toHaveLength(3);
+            // Step 1: PreparedCalls on Base
+            const step1 = decryptedPayload.content.value.steps[0];
+            expect(step1.content.case).toBe('preparedCalls');
+            if (step1.content.case === 'preparedCalls') {
+                expect(step1.content.value.id).toEqual(expect.any(String));
+                expect(step1.content.value.chainId).toBe('8453');
+                expect(step1.content.value.context).toBe('{"step":"approve"}');
+                expect(step1.content.value.title).toBe('Approve USDC on Base');
+            }
+            // Step 2: PreparedCalls on Mainnet
+            const step2 = decryptedPayload.content.value.steps[1];
+            expect(step2.content.case).toBe('preparedCalls');
+            if (step2.content.case === 'preparedCalls') {
+                expect(step2.content.value.id).toEqual(expect.any(String));
+                expect(step2.content.value.chainId).toBe('1');
+                expect(step2.content.value.context).toBe('{"step":"swap"}');
+                expect(step2.content.value.title).toBe('Swap on Mainnet');
+            }
+            // Step 3: Signature on Mainnet
+            const step3 = decryptedPayload.content.value.steps[2];
+            expect(step3.content.case).toBe('signature');
+            if (step3.content.case === 'signature') {
+                expect(step3.content.value.id).toEqual(expect.any(String));
+                expect(step3.content.value.data).toBe('0xdeadbeef');
+                expect(step3.content.value.chainId).toBe('1');
+                expect(step3.content.value.type).toBe(InteractionRequestPayload_Signature_SignatureType.TYPED_DATA);
+            }
+        }
+    });
+    it('joinUser should set appAddress when adding bot to GDM', async () => {
+        // Create a GDM with bob and carol (no bot yet)
+        const { streamId: testGdmId } = await bobClient.gdms.createGDM([carol.userId]);
+        await bobClient.riverConnection.call((client) => client.waitForStream(testGdmId));
+        // Add the bot to the GDM with appAddress
+        await bobClient.riverConnection.call((client) => client.joinUser(testGdmId, botClientAddress));
+        // Verify the bot's membership has appAddress set
+        await waitFor(async () => {
+            const gdmStreamView = await bobClient.riverConnection.call((client) => client.getStream(testGdmId));
+            const { joined } = gdmStreamView.getMembers();
+            expect(joined.get(botClientAddress)?.appAddress).toBe(appAddress);
+        });
+    });
+    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 join another app to a GDM via joinUser', async () => {
+        const { streamId: gdmId } = await bobClient.gdms.createGDM([carol.userId, botClientAddress]);
+        await bobClient.riverConnection.call((client) => client.waitForStream(gdmId));
+        const gdm = bobClient.gdms.getGdm(gdmId);
+        const app2Result = await createAppForOwner(bobClient, {
+            username: `app2_${genId(8)}`,
+            displayName: 'App 2',
+            description: 'Second app for joinUser test',
+            imageUrl: 'https://placehold.co/600x600',
+        });
+        const app2Address = app2Result.appAddress;
+        await bot.joinUser(gdmId, app2Address);
+        await waitFor(() => {
+            expect(gdm.members.value.userIds).toContain(app2Address);
+        });
+        const app2Id = bin_fromHexString(app2Address);
+        await appRegistryRpcClient.updateAppSettings({
+            appId: app2Id,
+            forwardSetting: ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES,
+            updateMask: ['forward_setting'],
+        });
+        const app2Agent = await makeTownsApp(app2Result.appPrivateData, {
+            jwtSecret: app2Result.jwtSecretBase64,
+            commands: [],
+        });
+        const app2Port = Number(process.env.BOT_PORT) + 2;
+        const app2WebhookUrl = `http://localhost:${app2Port}/webhook`;
+        const app2 = app2Agent.start();
+        const app2Server = serve({
+            port: app2Port,
+            fetch: app2.fetch,
+        });
+        await appRegistryRpcClient.registerWebhook({
+            appId: bin_fromHexString(app2Address),
+            webhookUrl: app2WebhookUrl,
+        });
+        const receivedByApp2 = [];
+        subscriptions.push(app2Agent.onMessage((_h, e) => {
+            receivedByApp2.push(e);
+        }));
+        try {
+            const messageText = 'Hi app2, welcome to the GDM.';
+            const { eventId } = await gdm.sendMessage(messageText);
+            await waitFor(() => receivedByApp2.length > 0, { timeoutMS: 15_000 });
+            const receivedMessage = receivedByApp2.find((x) => x.eventId === eventId);
+            expect(receivedMessage).toBeDefined();
+            expect(receivedMessage?.message).toBe(messageText);
+            expect(receivedMessage?.userId).toBe(bob.userId);
+        }
+        finally {
+            app2Server.close();
+        }
+    });
+    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_${genId(8)}`,
+                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)
+        const agent2Id = bin_fromHexString(agent2Address);
+        await appRegistryRpcClient.updateAppSettings({
+            appId: agent2Id,
+            forwardSetting: ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES,
+            updateMask: ['forward_setting'],
+        });
+        const agent2 = await makeTownsApp(agent2Result.appPrivateData, {
+            jwtSecret: agent2Result.jwtSecretBase64,
+            commands: [],
+        });
+        // Start agent2 server on a different port
+        const agent2Port = Number(process.env.BOT_PORT) + 1;
+        const agent2WebhookUrl = `http://localhost:${agent2Port}/webhook`;
+        const app2 = agent2.start();
+        serve({
+            port: agent2Port,
+            fetch: app2.fetch,
+        });
+        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
+    });
+    it('bot should send conversationSeed and bob should receive it', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const testSeed = {
+            id: 'seed-001',
+            createdAtMs: BigInt(Date.now()),
+            proposalTimeoutMs: 30000n,
+            conciergeTimeoutMs: 60000n,
+            conciergeId: new Uint8Array(20),
+            version: 1n,
+            query: 'What is the best swap for ETH to USDC?',
+            responseText: 'Here are some options for swapping ETH to USDC.',
+            proposals: [
+                {
+                    id: 'prop-001',
+                    targetAgentId: new Uint8Array(20),
+                    targetAgentName: 'Swap Agent',
+                    capabilityName: 'swap',
+                    parameters: '{"from":"ETH","to":"USDC"}',
+                    explanation: 'Swap ETH to USDC via Uniswap',
+                    confidence: 0.95,
+                    expiresAtMs: 0n,
+                    warnings: [],
+                    title: 'Swap ETH to USDC',
+                },
+            ],
+            invocations: [],
+            invocationsUpdatedAtMs: 0n,
+            proposalsByAgent: {},
+            selectedProposalIds: [],
+            clarifyingQuestions: ['How much ETH do you want to swap?'],
+            conciergeRespondedAtMs: 0n,
+            statusUpdates: [],
+            userTimezone: 'America/New_York',
+            conciergeFailedAtMs: 0n,
+        };
+        const { eventId } = await bot.sendConversationSeed(channelId, testSeed);
+        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.ConversationSeed);
+    });
+    it('bot should receive conversationSeedResponse sent by bob', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedResponses = [];
+        subscriptions.push(bot.onConversationSeedResponse((_h, e) => {
+            receivedResponses.push(e);
+        }));
+        // Bob sends a conversationSeedResponse with a userMessage
+        const { eventId } = await bobClient.riverConnection.call((client) => client.sendChannelMessage_ConversationSeedResponse(channelId, {
+            content: {
+                seedId: 'seed-001',
+                response: {
+                    case: 'userMessage',
+                    value: 'I want to swap 1 ETH',
+                },
+            },
+        }));
+        await waitFor(() => receivedResponses.length > 0);
+        const event = receivedResponses.find((x) => x.eventId === eventId);
+        expect(event).toBeDefined();
+        expect(event?.seedId).toBe('seed-001');
+        expect(event?.seed).toBeUndefined();
+        expect(event?.response.case).toBe('userMessage');
+        expect(event?.response.value).toBe('I want to swap 1 ETH');
+    });
+    it('bot should receive conversationSeedResponse with selectedProposal', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        const receivedResponses = [];
+        subscriptions.push(bot.onConversationSeedResponse((_h, e) => {
+            receivedResponses.push(e);
+        }));
+        // Bob sends a conversationSeedResponse selecting a proposal
+        const { eventId } = await bobClient.riverConnection.call((client) => client.sendChannelMessage_ConversationSeedResponse(channelId, {
+            content: {
+                seedId: 'seed-001',
+                response: {
+                    case: 'selectedProposal',
+                    value: {
+                        id: 'prop-001',
+                        targetAgentId: new Uint8Array(20),
+                        targetAgentName: 'Swap Agent',
+                        capabilityName: 'swap',
+                        parameters: '{"from":"ETH","to":"USDC"}',
+                        explanation: 'Swap ETH to USDC via Uniswap',
+                        confidence: 0.95,
+                        expiresAtMs: 0n,
+                        warnings: [],
+                        title: 'Swap ETH to USDC',
+                    },
+                },
+            },
+        }));
+        await waitFor(() => receivedResponses.length > 0);
+        const event = receivedResponses.find((x) => x.eventId === eventId);
+        expect(event).toBeDefined();
+        expect(event?.seedId).toBe('seed-001');
+        expect(event?.response.case).toBe('selectedProposal');
+        if (event?.response.case === 'selectedProposal') {
+            expect(event.response.value.id).toBe('prop-001');
+            expect(event.response.value.targetAgentName).toBe('Swap Agent');
+            expect(event.response.value.capabilityName).toBe('swap');
+        }
+    });
+    it.skip('bot should handle proposals request and return proposals', async () => {
+        const unsub = bot.onCapability('swap', (_handler, event) => {
+            expect(event.capabilityName).toBe('swap');
+            expect(event.userQuery).toBe('Swap 1 ETH to USDC');
+            return [
+                {
+                    title: 'Swap ETH to USDC',
+                    explanation: 'Swap 1 ETH for ~2000 USDC via Uniswap',
+                    confidence: 0.95,
+                    parameters: JSON.stringify({ from: 'ETH', to: 'USDC', amount: '1' }),
+                    warnings: ['Slippage may apply'],
+                    expectedOutcome: '~2000 USDC',
+                },
+            ];
+        });
+        subscriptions.push(unsub);
+        const { conversationSeedId } = await appRegistryRpcClient.queryConcierge({
+            query: 'Swap 1 ETH to USDC',
+        });
+        const resp = await appRegistryRpcClient.getBulkAgentProposals({
+            conversationSeedId,
+            requests: [
+                {
+                    agentId: bin_fromHexString(botClientAddress),
+                    capabilityName: 'swap',
+                    parameters: '{"from":"ETH","to":"USDC","amount":"1"}',
+                },
+            ],
+        });
+        expect(resp.accepted).toBe(true);
+    });
+    it.skip('bot should return accepted for unknown capability in proposals request', async () => {
+        const { conversationSeedId } = await appRegistryRpcClient.queryConcierge({
+            query: 'Do something unknown',
+        });
+        const resp = await appRegistryRpcClient.getBulkAgentProposals({
+            conversationSeedId,
+            requests: [
+                {
+                    agentId: bin_fromHexString(botClientAddress),
+                    capabilityName: 'nonexistent_capability',
+                    parameters: '{}',
+                },
+            ],
+        });
+        expect(resp.accepted).toBe(true);
+    });
+    it.skip('bot should return multiple proposals from a single capability handler', async () => {
+        const unsub = bot.onCapability('multi_swap', (_handler, _event) => {
+            return [
+                {
+                    title: 'Uniswap Direct',
+                    explanation: 'Route A: Uniswap direct',
+                    confidence: 0.9,
+                    parameters: '{"route":"uniswap"}',
+                },
+                {
+                    title: '1inch Aggregator',
+                    explanation: 'Route B: 1inch aggregator',
+                    confidence: 0.85,
+                    parameters: '{"route":"1inch"}',
+                },
+            ];
+        });
+        subscriptions.push(unsub);
+        const { conversationSeedId } = await appRegistryRpcClient.queryConcierge({
+            query: 'Best route for ETH to USDC',
+        });
+        const resp = await appRegistryRpcClient.getBulkAgentProposals({
+            conversationSeedId,
+            requests: [
+                {
+                    agentId: bin_fromHexString(botClientAddress),
+                    capabilityName: 'multi_swap',
+                    parameters: '{}',
+                },
+            ],
+        });
+        expect(resp.accepted).toBe(true);
+    });
+    it('bot should handle positions request and return positions via webhook', async () => {
+        const unsub = bot.onPositions((_handler, event) => {
+            expect(event.userId).toBeDefined();
+            return {
+                supported: true,
+                positions: [
+                    {
+                        label: 'ETH-PERP Long',
+                        symbol: 'ETH',
+                        type: PositionType.PERPETUAL,
+                        balanceUsd: '5000.00',
+                        pnlUsd: '+250.00',
+                        description: '10x leverage',
+                    },
+                ],
+                timestamp: BigInt(Date.now()),
+            };
+        });
+        subscriptions.push(unsub);
+        // Enable positions API so app registry will forward positions requests
+        const posAppId = bin_fromHexString(botClientAddress);
+        await appRegistryRpcClient.updateAppSettings({
+            appId: posAppId,
+            supportedApis: [SupportedApi.POSITIONS],
+            updateMask: ['supported_apis'],
+        });
+        // Request positions through app registry (which proxies to bot webhook)
+        const result = await appRegistryRpcClient.getAppPositions({
+            appId: bin_fromHexString(botClientAddress),
+        });
+        expect(result.positions).toBeDefined();
+        expect(result.positions.supported).toBe(true);
+        expect(result.positions.positions).toHaveLength(1);
+        expect(result.positions.positions[0].label).toBe('ETH-PERP Long');
+        expect(result.positions.positions[0].symbol).toBe('ETH');
+        expect(result.positions.positions[0].balanceUsd).toBe('5000.00');
+        expect(result.positions.positions[0].pnlUsd).toBe('+250.00');
+    });
+    it('getBulkAgentCapabilities should return capabilities for registered bot', async () => {
+        // Register a capability on the bot
+        const unsub = bot.onCapability('e2e_swap', (_handler, _event) => {
+            return [
+                {
+                    title: 'Test Swap',
+                    explanation: 'test',
+                    confidence: 1.0,
+                    parameters: '{}',
+                },
+            ];
+        });
+        subscriptions.push(unsub);
+        // Update capabilities via the app registry
+        await appRegistryRpcClient.updateAppMetadata({
+            appId: bin_fromHexString(botClientAddress),
+            metadata: {
+                capabilities: [
+                    {
+                        name: 'e2e_swap',
+                        description: 'Swap tokens',
+                        inputSchema: '{"type":"object"}',
+                        examples: [{ userQuery: 'swap ETH', parameters: '{}' }],
+                    },
+                ],
+            },
+            updateMask: ['capabilities'],
+        });
+        const resp = await appRegistryRpcClient.getBulkAgentCapabilities({
+            agentIds: [bin_fromHexString(botClientAddress)],
+        });
+        expect(resp.manifests.length).toBe(1);
+        const manifest = resp.manifests[0];
+        expect(manifest.agentName).toBeTruthy();
+        expect(manifest.capabilities.length).toBe(1);
+        expect(manifest.capabilities[0].name).toBe('e2e_swap');
+        expect(manifest.capabilities[0].description).toBe('Swap tokens');
+        expect(manifest.capabilities[0].inputSchema).toBe('{"type":"object"}');
+    });
+    it.skip('getBulkAgentProposals should fan out to bot and return proposals', async () => {
+        const unsub = bot.onCapability('e2e_propose', (_handler, event) => {
+            expect(event.userQuery).toBe('What can you do?');
+            return [
+                {
+                    title: 'Demo Action',
+                    explanation: 'I can do many things',
+                    confidence: 0.9,
+                    parameters: JSON.stringify({ action: 'demo' }),
+                    warnings: ['This is a test'],
+                },
+            ];
+        });
+        subscriptions.push(unsub);
+        // Update capabilities so the bot is discoverable
+        await appRegistryRpcClient.updateAppMetadata({
+            appId: bin_fromHexString(botClientAddress),
+            metadata: {
+                capabilities: [
+                    {
+                        name: 'e2e_propose',
+                        description: 'Demo capability',
+                        inputSchema: '{"type":"object"}',
+                        examples: [],
+                    },
+                ],
+            },
+            updateMask: ['capabilities'],
+        });
+        const { conversationSeedId } = await appRegistryRpcClient.queryConcierge({
+            query: 'What can you do?',
+        });
+        const resp = await appRegistryRpcClient.getBulkAgentProposals({
+            conversationSeedId,
+            requests: [
+                {
+                    agentId: bin_fromHexString(botClientAddress),
+                    capabilityName: 'e2e_propose',
+                    parameters: '{"action":"demo"}',
+                },
+            ],
+        });
+        expect(resp.accepted).toBe(true);
+    });
+    it.skip('getBulkAgentProposals should return accepted for unknown capability', async () => {
+        const { conversationSeedId } = await appRegistryRpcClient.queryConcierge({
+            query: 'Test unknown',
+        });
+        const resp = await appRegistryRpcClient.getBulkAgentProposals({
+            conversationSeedId,
+            requests: [
+                {
+                    agentId: bin_fromHexString(botClientAddress),
+                    capabilityName: 'nonexistent_capability',
+                    parameters: '{}',
+                },
+            ],
+        });
+        expect(resp.accepted).toBe(true);
+    });
+    it('agent should participate in key exchange', async () => {
+        await setForwardSetting(ForwardSettingValue.FORWARD_SETTING_ALL_MESSAGES);
+        // create a new gdm with bob and bot
+        const { streamId: gdmId } = await bobClient.gdms.createGDM([bot.agentUserId]);
+        await bobClient.riverConnection.call((client) => client.waitForStream(gdmId));
+        const gdm = bobClient.gdms.getGdm(gdmId);
+        // bob sends a message "hello world this is bob"
+        const { eventId: messageId } = await gdm.sendMessage('hello world this is bob');
+        // bob creates an invite link
+        const { appRegistryRpcClient } = await AppRegistryService.authenticate(bobClient.riverConnection.signerContext, townsEnv().getAppRegistryUrl());
+        const createResponse = await appRegistryRpcClient.createInviteLink({
+            streamId: streamIdAsBytes(gdmId),
+            inviteEncryptionData: await bobClient.riverConnection.call((client) => client.exportInviteEncryptionData(gdmId)),
+        });
+        const inviteCode = createResponse.inviteCode;
+        expect(inviteCode).toBeDefined();
+        expect(inviteCode.length).toBeGreaterThan(0);
+        // bob leaves the gdm
+        await gdm.leave();
+        // delete the keys from the bot to simulate a server restart
+        await bot['client'].crypto.cryptoStore.deleteHybridGroupSessions(gdmId);
+        // alice joins the gdm
+        const { appRegistryRpcClient: aliceAppRegistryRpcClient } = await AppRegistryService.authenticate(aliceClient.riverConnection.signerContext, townsEnv().getAppRegistryUrl());
+        const redeemResponse = await aliceAppRegistryRpcClient.redeemInviteLink({ inviteCode });
+        // NOTE - we redeemed the invite link, but we didn't import the encryption data into the bot
+        // forcing alice to use key exchange to decrypt the message
+        redeemResponse.inviteEncryptionData = undefined; // clear it to force key exchange
+        log('joining gdm', gdmId);
+        const stream = await aliceClient.joinStream(gdmId, {
+            redeemedInvite: redeemResponse,
+        });
+        log('stream', stream);
+        // alice sees the message decrypted in the gdm
+        const aliceGdm = aliceClient.gdms.getGdm(gdmId);
+        await waitFor(() => expect(aliceGdm.timeline.events.value.find((x) => x.eventId === messageId)?.content?.kind).toBe(RiverTimelineEvent.ChannelMessage));
+    });
+});
+//# sourceMappingURL=app.test.js.map