@towns-labs/app-framework 4.0.0

package/dist/app.js

@@ -0,0 +1,2324 @@
+import { create, fromBinary, fromJsonString, toBinary, toJsonString } from '@bufbuild/protobuf';
+import { utils } from 'ethers';
+import { ETH_ADDRESS } from '@towns-labs/web3';
+import { stringify as superjsonStringify, parse as superjsonParse } from 'superjson';
+var TipRecipientType;
+(function (TipRecipientType) {
+    TipRecipientType[TipRecipientType["Member"] = 0] = "Member";
+    TipRecipientType[TipRecipientType["Bot"] = 1] = "Bot";
+    TipRecipientType[TipRecipientType["Any"] = 2] = "Any";
+})(TipRecipientType || (TipRecipientType = {}));
+const tippingFacetAbi = [
+    {
+        type: 'function',
+        name: 'sendTip',
+        inputs: [
+            { name: 'recipientType', type: 'uint8' },
+            { name: 'data', type: 'bytes' },
+        ],
+        outputs: [],
+        stateMutability: 'payable',
+    },
+    {
+        type: 'event',
+        name: 'TipSent',
+        inputs: [
+            { name: 'sender', type: 'address', indexed: true },
+            { name: 'receiver', type: 'address', indexed: true },
+            { name: 'recipientType', type: 'uint8', indexed: true },
+            { name: 'currency', type: 'address', indexed: false },
+            { name: 'amount', type: 'uint256', indexed: false },
+            { name: 'data', type: 'bytes', indexed: false },
+        ],
+        anonymous: false,
+    },
+];
+import { getRefEventIdFromChannelMessage, createTownsClient, streamIdAsString, make_MemberPayload_KeyFulfillment, make_MemberPayload_KeySolicitation, make_UserInboxPayload_GroupEncryptionSessions, make_UserMetadataPayload_EncryptionDevice, logNever, makeUserInboxStreamId, userIdFromAddress, makeUserMetadataStreamId, unsafe_makeTags, townsEnv, parseAppPrivateData, makeEvent, make_MediaPayload_Inception, make_MediaPayload_Chunk, makeUniqueMediaStreamId, streamIdAsBytes, addressFromUserId, make_payload_InteractionRequest, userIdToAddress, unpackEnvelope, make_UserPayload_BlockchainTransaction, make_UserPayload_UserMembershipAction, makeUserStreamId, make_MemberPayload_Pin, make_MemberPayload_Unpin, isGDMChannelStreamId, make_GDMChannelPayload_Message, } from '@towns-labs/sdk';
+import { Hono } from 'hono';
+import { logger } from 'hono/logger';
+import { createMiddleware } from 'hono/factory';
+import { default as jwt } from 'jsonwebtoken';
+import { createNanoEvents } from 'nanoevents';
+import imageSize from 'image-size';
+import { ChannelMessageSchema, AppServiceRequestSchema, AppServiceResponseSchema, MembershipOp, MessageInteractionType, ChannelMessage_Post_Content_ImageSchema, ChannelMessage_Post_Content_Image_InfoSchema, ChannelMessage_Post_Content_InfoCardSchema, ChannelMessage_Post_Content_InfoCard_LabelSchema, ChannelMessage_Post_Content_InfoCard_FieldSchema, ChannelMessage_Post_Content_InfoCard_UserRefSchema, ChannelMessage_Post_Content_InfoCard_TokenAmountSchema, ChannelMessage_Post_Content_InfoCard_ContractRefSchema, ChannelMessage_Post_Content_InfoCard_MarketItemSchema, ChannelMessage_Post_Content_InfoCard_MarketItem_OutcomeSchema, ChannelMessage_Post_Content_InfoCard_Label_Icon, ChannelMessage_Post_Content_InfoCard_Label_Badge_Variant, ChunkedMediaSchema, CreationCookieSchema, SessionKeysSchema, BlockchainTransactionSchema, InteractionRequestPayloadSchema, InteractionResponsePayloadSchema, ChannelMessage_Post_AttachmentSchema, ChannelMessage_Post_MentionSchema, ConciergeFinishStatus, } from '@towns-labs/proto';
+import { bin_equal, bin_fromBase64, bin_fromHexString, bin_toHexString, check, dlog, } from '@towns-labs/utils';
+import { encryptChunkedAESGCM } from '@towns-labs/sdk-crypto';
+import { EventDedup } from './modules/eventDedup';
+import { UserInfoCache, getUserBulk } from './modules/user';
+import { isFlattenedRequest, flattenedToPayloadContent, } from './modules/interaction-api';
+import { chainIdToNetwork, createPaymentRequest } from './modules/payments';
+import { useFacilitator } from 'x402/verify';
+import { http, createWalletClient, encodeAbiParameters, zeroAddress, parseEventLogs, formatUnits, erc20Abi, } from 'viem';
+import { readContract, waitForTransactionReceipt, writeContract } from 'viem/actions';
+import { base, baseSepolia, foundry } from 'viem/chains';
+import packageJson from '../package.json' with { type: 'json' };
+import { privateKeyToAccount } from 'viem/accounts';
+const appRegistryAbi = [
+    {
+        type: 'function',
+        name: 'getAppByClient',
+        inputs: [{ name: 'client', type: 'address' }],
+        outputs: [{ name: '', type: 'address' }],
+        stateMutability: 'view',
+    },
+];
+import { EmptySchema } from '@bufbuild/protobuf/wkt';
+const debug = dlog('csb:agent');
+export class App {
+    client;
+    appAddress;
+    agentUserId;
+    viem;
+    jwtSecret;
+    currentMessageTags;
+    emitter = createNanoEvents();
+    slashCommandHandlers = new Map();
+    gmTypedHandlers = new Map();
+    commands;
+    capabilities;
+    capabilityHandlers = new Map();
+    conciergeRequestHandler;
+    positionsHandler;
+    metadata;
+    identityConfig;
+    eventDedup;
+    // Payment related members
+    paymentConfig;
+    pendingPayments = new Map();
+    paymentCommands = new Map();
+    // User info cache
+    userInfoCache = new UserInfoCache();
+    constructor(clientV2, viem, jwtSecretBase64, appAddress, commands, capabilities, identityConfig, dedupConfig, paymentConfig, metadata = {}) {
+        this.client = clientV2;
+        this.agentUserId = clientV2.userId;
+        this.viem = viem;
+        this.jwtSecret = bin_fromBase64(jwtSecretBase64);
+        this.currentMessageTags = undefined;
+        this.commands = commands;
+        this.capabilities = capabilities;
+        this.appAddress = appAddress;
+        this.identityConfig = identityConfig;
+        this.eventDedup = new EventDedup(dedupConfig);
+        this.paymentConfig = paymentConfig;
+        this.metadata = metadata;
+        if (commands && paymentConfig) {
+            for (const cmd of commands) {
+                if (cmd.paid?.price) {
+                    this.paymentCommands.set(cmd.name, cmd.paid);
+                }
+            }
+        }
+        this.onInteractionResponse(this.handlePaymentResponse.bind(this));
+    }
+    async getUser(userIdOrIds) {
+        if (Array.isArray(userIdOrIds)) {
+            return getUserBulk(userIdOrIds, this.userInfoCache, () => this.client.appServiceClient());
+        }
+        const result = await getUserBulk([userIdOrIds], this.userInfoCache, () => this.client.appServiceClient());
+        return result.get(userIdOrIds);
+    }
+    start() {
+        const jwtMiddleware = createMiddleware(this.jwtMiddleware.bind(this));
+        const handler = this.webhookHandler.bind(this);
+        const app = new Hono();
+        app.use(logger());
+        app.post('/webhook', jwtMiddleware, handler);
+        app.get('/.well-known/agent-metadata.json', async (c) => {
+            return c.json(await this.getIdentityMetadata());
+        });
+        debug('init');
+        return app;
+    }
+    async jwtMiddleware(c, next) {
+        const authHeader = c.req.header('Authorization');
+        if (!authHeader || !authHeader.startsWith('Bearer ')) {
+            return c.text('Unauthorized: Missing or malformed token', 401);
+        }
+        const tokenString = authHeader.substring(7);
+        try {
+            const agentAddressBytes = bin_fromHexString(this.agentUserId);
+            const expectedAudience = bin_toHexString(agentAddressBytes);
+            jwt.verify(tokenString, Buffer.from(this.jwtSecret), {
+                algorithms: ['HS256'],
+                audience: expectedAudience,
+            });
+        }
+        catch (err) {
+            let errorMessage = 'Unauthorized: Token verification failed';
+            if (err instanceof jwt.TokenExpiredError) {
+                errorMessage = 'Unauthorized: Token expired';
+            }
+            else if (err instanceof jwt.JsonWebTokenError) {
+                errorMessage = `Unauthorized: Invalid token (${err.message})`;
+            }
+            return c.text(errorMessage, 401);
+        }
+        await next();
+    }
+    async webhookHandler(c) {
+        const body = await c.req.arrayBuffer();
+        const encryptionDevice = this.client.crypto.getUserDevice();
+        const request = fromBinary(AppServiceRequestSchema, new Uint8Array(body));
+        debug('webhook', request);
+        const statusResponse = create(AppServiceResponseSchema, {
+            payload: {
+                case: 'status',
+                value: {
+                    frameworkVersion: 1,
+                    clientVersion: `javascript:${packageJson.name}:${packageJson.version}`,
+                    deviceKey: encryptionDevice.deviceKey,
+                    fallbackKey: encryptionDevice.fallbackKey,
+                },
+            },
+        });
+        let response = statusResponse;
+        if (request.payload.case === 'initialize') {
+            response = create(AppServiceResponseSchema, {
+                payload: {
+                    case: 'initialize',
+                    value: {
+                        encryptionDevice,
+                    },
+                },
+            });
+        }
+        else if (request.payload.case === 'events') {
+            for (const event of request.payload.value.events) {
+                try {
+                    await this.handleEvent(event);
+                }
+                catch (err) {
+                    // eslint-disable-next-line no-console
+                    console.error('[@towns-labs/app-framework] Error while handling event', err);
+                }
+            }
+            response = statusResponse;
+        }
+        else if (request.payload.case === 'status') {
+            response = statusResponse;
+        }
+        else if (request.payload.case === 'proposals') {
+            const proposalsRequest = request.payload.value;
+            // Fire-and-forget: process proposals async, respond accepted immediately
+            this.processProposals(proposalsRequest).catch((err) => 
+            // eslint-disable-next-line no-console
+            console.error('[@towns-labs/app-framework] proposals processing error', err));
+            response = create(AppServiceResponseSchema, {
+                payload: {
+                    case: 'proposals',
+                    value: { accepted: true },
+                },
+            });
+        }
+        else if (request.payload.case === 'conciergeRequest') {
+            const conciergeReq = request.payload.value;
+            if (this.conciergeRequestHandler) {
+                // Fire-and-forget: process concierge request async, respond accepted
+                // immediately. Once the handler resolves, persist the concierge output
+                // back to the seed via FinishConversationSeed.
+                this.conciergeRequestHandler(this.client, {
+                    conversationSeedId: conciergeReq.conversationSeedId,
+                    userQuery: conciergeReq.userQuery,
+                    context: conciergeReq.context,
+                    externalRef: conciergeReq.externalRef,
+                    proposalTimeoutMs: conciergeReq.proposalTimeoutMs,
+                    conciergeTimeoutMs: conciergeReq.conciergeTimeoutMs,
+                    userTimezone: conciergeReq.userTimezone,
+                })
+                    .then(async (seedUpdate) => {
+                    if (seedUpdate) {
+                        try {
+                            const appService = await this.client.appServiceClient();
+                            await appService.finishConversationSeed({
+                                conversationSeedId: conciergeReq.conversationSeedId,
+                                responseText: seedUpdate.responseText ?? '',
+                                selectedProposalIds: seedUpdate.selectedProposalIds ?? [],
+                                clarifyingQuestions: seedUpdate.clarifyingQuestions ?? [],
+                            });
+                        }
+                        catch (finishErr) {
+                            // eslint-disable-next-line no-console
+                            console.error('[@towns-labs/app-framework] failed to persist concierge result', finishErr);
+                        }
+                    }
+                })
+                    .catch(async (err) => {
+                    // eslint-disable-next-line no-console
+                    console.error('[@towns-labs/app-framework] conciergeRequest error', err);
+                    try {
+                        const appService = await this.client.appServiceClient();
+                        await appService.finishConversationSeed({
+                            conversationSeedId: conciergeReq.conversationSeedId,
+                            responseText: 'Something went wrong. Please try again.',
+                            selectedProposalIds: [],
+                            clarifyingQuestions: [],
+                            status: ConciergeFinishStatus.FAILURE,
+                        });
+                    }
+                    catch (finishErr) {
+                        // eslint-disable-next-line no-console
+                        console.error('[@towns-labs/app-framework] failed to finalize seed after error', finishErr);
+                    }
+                });
+            }
+            response = create(AppServiceResponseSchema, {
+                payload: {
+                    case: 'conciergeResponse',
+                    value: { accepted: true },
+                },
+            });
+        }
+        else if (request.payload.case === 'positions') {
+            const positionsRequest = request.payload.value;
+            if (this.positionsHandler) {
+                const result = await this.positionsHandler(this.client, {
+                    userId: userIdFromAddress(positionsRequest.userId),
+                });
+                response = create(AppServiceResponseSchema, {
+                    payload: {
+                        case: 'positions',
+                        value: result,
+                    },
+                });
+            }
+            else {
+                response = create(AppServiceResponseSchema, {
+                    payload: {
+                        case: 'positions',
+                        value: {
+                            supported: false,
+                            positions: [],
+                            timestamp: BigInt(Date.now()),
+                        },
+                    },
+                });
+            }
+        }
+        c.header('Content-Type', 'application/x-protobuf');
+        return c.body(toBinary(AppServiceResponseSchema, response), 200);
+    }
+    async processProposals(proposalsRequest) {
+        const proposals = [];
+        const errors = [];
+        const tasks = proposalsRequest.invocations.map(async (invocation) => {
+            const capabilityName = invocation.capabilityName;
+            const handler = this.capabilityHandlers.get(capabilityName);
+            if (!handler) {
+                return {
+                    ok: false,
+                    capabilityName,
+                    error: `Unknown capability: ${capabilityName}`,
+                };
+            }
+            try {
+                const parsed = JSON.parse(invocation.parameters || '{}');
+                const results = await handler(this.client, {
+                    capabilityName,
+                    parameters: parsed,
+                    userQuery: proposalsRequest.userQuery,
+                    context: proposalsRequest.context,
+                    timeoutMs: proposalsRequest.timeoutMs,
+                });
+                return { ok: true, capabilityName, invocation, results };
+            }
+            catch (err) {
+                return {
+                    ok: false,
+                    capabilityName,
+                    error: err instanceof Error ? err.message : 'Unknown error',
+                };
+            }
+        });
+        const settled = await Promise.all(tasks);
+        let proposalIndex = 0;
+        for (const outcome of settled) {
+            if (!outcome.ok) {
+                errors.push({
+                    agentId: bin_fromHexString(this.agentUserId),
+                    error: outcome.error,
+                });
+            }
+            else {
+                try {
+                    for (const r of outcome.results) {
+                        proposals.push({
+                            id: `${outcome.capabilityName}_${proposalIndex++}`,
+                            targetAgentId: bin_fromHexString(this.agentUserId),
+                            targetAgentName: this.metadata.displayName,
+                            capabilityName: outcome.capabilityName,
+                            parameters: r.parameters ?? outcome.invocation.parameters,
+                            explanation: r.explanation,
+                            confidence: r.confidence,
+                            expiresAtMs: r.expiresAt ? BigInt(r.expiresAt.getTime()) : 0n,
+                            warnings: r.warnings ?? [],
+                            expectedOutcome: r.expectedOutcome,
+                            title: r.title,
+                        });
+                    }
+                }
+                catch (err) {
+                    errors.push({
+                        agentId: bin_fromHexString(this.agentUserId),
+                        error: err instanceof Error ? err.message : 'Unknown error',
+                    });
+                }
+            }
+        }
+        const appService = await this.client.appServiceClient();
+        await appService.submitAgentProposals({
+            conversationSeedId: proposalsRequest.conversationSeedId,
+            proposals,
+            errors,
+        });
+    }
+    async handleEvent(appEvent) {
+        if (!appEvent.payload.case || !appEvent.payload.value)
+            return;
+        const streamId = streamIdAsString(appEvent.payload.value.streamId);
+        if (appEvent.payload.case === 'messages') {
+            const groupEncryptionSessionsPayloads = await this.client
+                .unpackEnvelopes(appEvent.payload.value.groupEncryptionSessionsMessages)
+                .then((x) => x.flatMap((e) => {
+                if (e.event.payload.case === 'userInboxPayload' &&
+                    e.event.payload.value.content.case === 'groupEncryptionSessions') {
+                    return e.event.payload.value.content.value;
+                }
+                return [];
+            }));
+            for (const sessions of groupEncryptionSessionsPayloads) {
+                await this.client.importGroupEncryptionSessions({
+                    streamId,
+                    sessions,
+                });
+            }
+            const events = await this.client.unpackEnvelopes(appEvent.payload.value.messages);
+            for (const parsed of events) {
+                if (parsed.creatorUserId === this.client.userId) {
+                    continue;
+                }
+                if (!parsed.event.payload.case) {
+                    continue;
+                }
+                // Skip duplicate events (App Registry may replay events during restarts)
+                if (this.eventDedup.checkAndAdd(streamId, parsed.hashStr)) {
+                    continue;
+                }
+                const createdAt = new Date(Number(parsed.event.createdAtEpochMs));
+                this.currentMessageTags = parsed.event.tags;
+                const creatorUserId = userIdFromAddress(parsed.event.creatorAddress);
+                const creatorUser = (await this.getUser(creatorUserId)) ?? {
+                    id: creatorUserId,
+                    displayName: '',
+                    username: '',
+                };
+                debug('emit:streamEvent', {
+                    userId: creatorUserId,
+                    channelId: streamId,
+                    eventId: parsed.hashStr,
+                });
+                this.emitter.emit('streamEvent', this.client, {
+                    ...createBasePayload(creatorUserId, streamId, parsed.hashStr, createdAt, parsed.event, creatorUser),
+                    parsed: parsed,
+                });
+                switch (parsed.event.payload.case) {
+                    case 'gdmChannelPayload': {
+                        if (!parsed.event.payload.value.content.case)
+                            return;
+                        if (parsed.event.payload.value.content.case === 'message') {
+                            const eventCleartext = await this.client.crypto.decryptGroupEvent(streamId, parsed.event.payload.value.content.value);
+                            if (eventCleartext === undefined) {
+                                debug('skipping event with unrecognized encryption algorithm', streamId);
+                                return;
+                            }
+                            let channelMessage;
+                            if (typeof eventCleartext === 'string') {
+                                channelMessage = fromJsonString(ChannelMessageSchema, eventCleartext);
+                            }
+                            else {
+                                channelMessage = fromBinary(ChannelMessageSchema, eventCleartext);
+                            }
+                            await this.handleChannelMessage(streamId, parsed, channelMessage, creatorUser);
+                        }
+                        else if (parsed.event.payload.value.content.case === 'redaction') {
+                            const refEventId = bin_toHexString(parsed.event.payload.value.content.value.eventId);
+                            debug('emit:eventRevoke', {
+                                userId: userIdFromAddress(parsed.event.creatorAddress),
+                                channelId: streamId,
+                                refEventId,
+                            });
+                            this.emitter.emit('eventRevoke', this.client, {
+                                ...createBasePayload(creatorUserId, streamId, parsed.hashStr, createdAt, parsed.event, creatorUser),
+                                refEventId,
+                            });
+                        }
+                        else if (parsed.event.payload.value.content.case === 'channelProperties') {
+                            // TODO: currently, no support for channel properties (update name, topic)
+                        }
+                        else if (parsed.event.payload.value.content.case === 'inception') {
+                            // TODO: is there any use case for this?
+                        }
+                        else if (parsed.event.payload.value.content.case === 'custom') {
+                            // TODO: what to do with custom payload for agent?
+                        }
+                        else if (parsed.event.payload.value.content.case === 'interactionRequest') {
+                            // ignored for agentss
+                        }
+                        else if (parsed.event.payload.value.content.case === 'interactionResponse') {
+                            const payload = parsed.event.payload.value.content.value;
+                            if (!bin_equal(payload.recipient, bin_fromHexString(this.agentUserId))) {
+                                continue;
+                            }
+                            if (!payload.encryptedData) {
+                                continue;
+                            }
+                            if (payload.encryptedData.deviceKey !== this.getUserDevice().deviceKey) {
+                                continue;
+                            }
+                            const decryptedBase64 = await this.client.crypto.decryptWithDeviceKey(payload.encryptedData.ciphertext, payload.encryptedData.senderKey);
+                            const decrypted = bin_fromBase64(decryptedBase64);
+                            const response = fromBinary(InteractionResponsePayloadSchema, decrypted);
+                            this.emitter.emit('interactionResponse', this.client, {
+                                ...createBasePayload(creatorUserId, streamId, parsed.hashStr, createdAt, parsed.event, creatorUser),
+                                response: {
+                                    recipient: payload.recipient,
+                                    payload: response,
+                                },
+                                threadId: payload.threadId
+                                    ? bin_toHexString(payload.threadId)
+                                    : undefined,
+                            });
+                        }
+                        else {
+                            logNever(parsed.event.payload.value.content);
+                        }
+                        break;
+                    }
+                    case 'memberPayload': {
+                        switch (parsed.event.payload.value.content.case) {
+                            case 'membership':
+                                {
+                                    const membership = parsed.event.payload.value.content.value;
+                                    const isGdm = isGDMChannelStreamId(streamId);
+                                    // TODO: do we want agent to listen to onSpaceJoin/onSpaceLeave?
+                                    if (!isGdm)
+                                        continue;
+                                    const memberUserId = userIdFromAddress(membership.userAddress);
+                                    const memberUser = (await this.getUser(memberUserId)) ?? {
+                                        id: memberUserId,
+                                        displayName: '',
+                                        username: '',
+                                    };
+                                    if (membership.op === MembershipOp.SO_JOIN) {
+                                        debug('emit:channelJoin', {
+                                            userId: memberUserId,
+                                            channelId: streamId,
+                                            eventId: parsed.hashStr,
+                                        });
+                                        this.emitter.emit('channelJoin', this.client, {
+                                            ...createBasePayload(memberUserId, streamId, parsed.hashStr, createdAt, parsed.event, memberUser),
+                                        });
+                                    }
+                                    if (membership.op === MembershipOp.SO_LEAVE) {
+                                        debug('emit:channelLeave', {
+                                            userId: memberUserId,
+                                            channelId: streamId,
+                                            eventId: parsed.hashStr,
+                                        });
+                                        this.emitter.emit('channelLeave', this.client, {
+                                            ...createBasePayload(memberUserId, streamId, parsed.hashStr, createdAt, parsed.event, memberUser),
+                                        });
+                                    }
+                                }
+                                break;
+                            case 'memberBlockchainTransaction':
+                                {
+                                    const transactionContent = parsed.event.payload.value.content.value.transaction
+                                        ?.content;
+                                    const fromUserAddress = parsed.event.payload.value.content.value.fromUserAddress;
+                                    switch (transactionContent?.case) {
+                                        case 'spaceReview':
+                                            break;
+                                        case 'tokenTransfer':
+                                            break;
+                                        case 'tip':
+                                            {
+                                                const tipEvent = transactionContent.value.event;
+                                                if (!tipEvent) {
+                                                    return;
+                                                }
+                                                const currency = utils.getAddress(bin_toHexString(tipEvent.currency));
+                                                const senderAddress = utils.getAddress(bin_toHexString(tipEvent.sender));
+                                                const receiverAddress = utils.getAddress(bin_toHexString(tipEvent.receiver));
+                                                const senderUserId = userIdFromAddress(fromUserAddress);
+                                                const receiverUserId = userIdFromAddress(transactionContent.value.toUserAddress);
+                                                debug('emit:tip', {
+                                                    senderAddress,
+                                                    senderUserId,
+                                                    receiverAddress,
+                                                    receiverUserId,
+                                                    amount: tipEvent.amount.toString(),
+                                                    currency,
+                                                    messageId: bin_toHexString(tipEvent.messageId),
+                                                });
+                                                const tipUser = (await this.getUser(senderUserId)) ?? {
+                                                    id: senderUserId,
+                                                    displayName: '',
+                                                    username: '',
+                                                };
+                                                this.emitter.emit('tip', this.client, {
+                                                    ...createBasePayload(senderUserId, streamId, parsed.hashStr, createdAt, parsed.event, tipUser),
+                                                    amount: tipEvent.amount,
+                                                    currency: currency,
+                                                    senderAddress,
+                                                    receiverAddress,
+                                                    receiverUserId,
+                                                    messageId: bin_toHexString(tipEvent.messageId),
+                                                });
+                                            }
+                                            break;
+                                        case undefined:
+                                            break;
+                                        default:
+                                            logNever(transactionContent);
+                                    }
+                                }
+                                break;
+                            case 'keySolicitation':
+                                await this.handleKeySolicitation(streamId, parsed);
+                                break;
+                            case 'keyFulfillment':
+                            case 'pin':
+                            case 'unpin':
+                            case 'encryptionAlgorithm':
+                            case 'setAppAddress':
+                            case 'unsetAppAddress':
+                                break;
+                            case undefined:
+                                break;
+                            default:
+                                logNever(parsed.event.payload.value.content);
+                        }
+                    }
+                }
+            }
+        }
+        else if (appEvent.payload.case === 'solicitation') {
+            const missingSessionIds = appEvent.payload.value.sessionIds.filter((sessionId) => sessionId !== '');
+            await this.client.sendKeySolicitation(streamId, missingSessionIds);
+        }
+        else {
+            logNever(appEvent.payload);
+        }
+    }
+    isGroupEncryptionSession(session) {
+        if (typeof session !== 'object' || session === null) {
+            return false;
+        }
+        const maybeSession = session;
+        return (typeof maybeSession.streamId === 'string' &&
+            typeof maybeSession.sessionId === 'string' &&
+            typeof maybeSession.sessionKey === 'string' &&
+            maybeSession.algorithm !== undefined);
+    }
+    async handleKeySolicitation(streamId, parsed) {
+        if (parsed.event.payload.case !== 'memberPayload' ||
+            parsed.event.payload.value.content.case !== 'keySolicitation') {
+            return;
+        }
+        const solicitation = parsed.event.payload.value.content.value;
+        const requesterUserId = userIdFromAddress(parsed.event.creatorAddress);
+        const myDevice = this.getUserDevice();
+        // Ignore our own solicitation.
+        if (solicitation.deviceKey === myDevice.deviceKey) {
+            return;
+        }
+        if (!solicitation.deviceKey || !solicitation.fallbackKey) {
+            return;
+        }
+        const requestedSessionIds = Array.from(new Set((Array.isArray(solicitation.sessionIds) ? solicitation.sessionIds : []).filter((sessionId) => typeof sessionId === 'string' && sessionId !== ''))).sort();
+        if (requestedSessionIds.length === 0) {
+            return;
+        }
+        const availableSessions = new Map();
+        for (const sessionId of requestedSessionIds) {
+            const localSession = await this.client.crypto.exportGroupSession(streamId, sessionId);
+            const session = this.isGroupEncryptionSession(localSession)
+                ? localSession
+                : undefined;
+            if (session) {
+                availableSessions.set(sessionId, session);
+            }
+        }
+        if (availableSessions.size === 0) {
+            return;
+        }
+        const fulfilledSessionIds = Array.from(availableSessions.keys()).sort();
+        await this.client.sendEvent(streamId, make_MemberPayload_KeyFulfillment({
+            userAddress: parsed.event.creatorAddress,
+            deviceKey: solicitation.deviceKey,
+            sessionIds: fulfilledSessionIds,
+        }), undefined, parsed.ephemeral);
+        const sessionsByAlgorithm = new Map();
+        for (const session of availableSessions.values()) {
+            const list = sessionsByAlgorithm.get(session.algorithm) ?? [];
+            list.push(session);
+            sessionsByAlgorithm.set(session.algorithm, list);
+        }
+        for (const [algorithm, sessions] of sessionsByAlgorithm.entries()) {
+            sessions.sort((a, b) => a.sessionId.localeCompare(b.sessionId));
+            const ciphertexts = await this.client.crypto.encryptWithDeviceKeys(toJsonString(SessionKeysSchema, create(SessionKeysSchema, {
+                keys: sessions.map((session) => session.sessionKey),
+            })), [
+                {
+                    deviceKey: solicitation.deviceKey,
+                    fallbackKey: solicitation.fallbackKey,
+                },
+            ]);
+            if (Object.keys(ciphertexts).length === 0) {
+                continue;
+            }
+            await this.client.sendEvent(makeUserInboxStreamId(requesterUserId), make_UserInboxPayload_GroupEncryptionSessions({
+                streamId: streamIdAsBytes(streamId),
+                senderKey: myDevice.deviceKey,
+                sessionIds: sessions.map((session) => session.sessionId),
+                ciphertexts,
+                algorithm,
+            }));
+        }
+    }
+    async handleChannelMessage(streamId, parsed, { payload }, user) {
+        if (!payload.case) {
+            return;
+        }
+        const createdAt = new Date(Number(parsed.event.createdAtEpochMs));
+        switch (payload.case) {
+            case 'post': {
+                if (payload.value.content.case === 'text') {
+                    const userId = userIdFromAddress(parsed.event.creatorAddress);
+                    const replyId = payload.value.replyId;
+                    const threadId = payload.value.threadId;
+                    const mentions = parseMentions(payload.value.content.value.mentions);
+                    const isMentioned = mentions.some((m) => m.userId.toLowerCase() === this.agentUserId.toLowerCase());
+                    const forwardPayload = {
+                        ...createBasePayload(userId, streamId, parsed.hashStr, createdAt, parsed.event, user),
+                        message: payload.value.content.value.body,
+                        mentions,
+                        isMentioned,
+                        replyId,
+                        threadId,
+                    };
+                    if (parsed.event.tags?.messageInteractionType ===
+                        MessageInteractionType.SLASH_COMMAND) {
+                        const { command, args } = parseSlashCommand(payload.value.content.value.body);
+                        const handler = this.slashCommandHandlers.get(command);
+                        if (handler) {
+                            void handler(this.client, {
+                                ...forwardPayload,
+                                command: command,
+                                args,
+                                replyId,
+                                threadId,
+                            });
+                        }
+                    }
+                    else {
+                        debug('emit:message', forwardPayload);
+                        this.emitter.emit('message', this.client, forwardPayload);
+                    }
+                }
+                else if (payload.value.content.case === 'gm') {
+                    const userId = userIdFromAddress(parsed.event.creatorAddress);
+                    const gmContent = payload.value.content.value;
+                    const { typeUrl, value } = gmContent;
+                    this.emitter.emit('rawGmMessage', this.client, {
+                        ...createBasePayload(userId, streamId, parsed.hashStr, createdAt, parsed.event, user),
+                        typeUrl,
+                        message: value ?? new Uint8Array(),
+                    });
+                    const typedHandler = this.gmTypedHandlers.get(typeUrl);
+                    if (typedHandler) {
+                        try {
+                            const possibleJsonString = new TextDecoder().decode(value);
+                            const deserializedData = superjsonParse(possibleJsonString);
+                            const result = await typedHandler.schema['~standard'].validate(deserializedData);
+                            if ('issues' in result && result.issues) {
+                                debug('GM validation failed', { typeUrl, issues: result.issues });
+                            }
+                            else {
+                                debug('emit:gmMessage', { userId, channelId: streamId });
+                                void typedHandler.handler(this.client, {
+                                    ...createBasePayload(userId, streamId, parsed.hashStr, createdAt, parsed.event, user),
+                                    typeUrl,
+                                    data: result.value,
+                                });
+                            }
+                        }
+                        catch (error) {
+                            debug('GM handler error', { typeUrl, error });
+                        }
+                    }
+                }
+                else if (payload.value.content.case === 'conversationSeedResponse') {
+                    const userId = userIdFromAddress(parsed.event.creatorAddress);
+                    const seedResponse = payload.value.content.value;
+                    debug('emit:conversationSeedResponse', {
+                        userId,
+                        channelId: streamId,
+                        seedId: seedResponse.seedId,
+                    });
+                    if (seedResponse.response.case === undefined) {
+                        return;
+                    }
+                    const basePayload = createBasePayload(userId, streamId, parsed.hashStr, createdAt, parsed.event, user);
+                    this.emitter.emit('conversationSeedResponse', this.client, {
+                        ...basePayload,
+                        seedId: seedResponse.seedId,
+                        seed: seedResponse.seed,
+                        response: seedResponse.response,
+                        replyId: payload.value.replyId,
+                        threadId: payload.value.threadId,
+                    });
+                    if (seedResponse.response.case === 'selectedProposal' &&
+                        `0x${bin_toHexString(seedResponse.response.value.targetAgentId)}`.toLowerCase() === this.appAddress.toLowerCase()) {
+                        debug('emit:selectedProposal', {
+                            userId,
+                            channelId: streamId,
+                            seedId: seedResponse.seedId,
+                            proposalId: seedResponse.response.value.id,
+                        });
+                        this.emitter.emit('selectedProposal', this.client, {
+                            ...basePayload,
+                            seedId: seedResponse.seedId,
+                            seed: seedResponse.seed,
+                            proposal: seedResponse.response.value,
+                            replyId: payload.value.replyId,
+                            threadId: payload.value.threadId,
+                        });
+                    }
+                }
+                break;
+            }
+            case 'reaction': {
+                debug('emit:reaction', {
+                    userId: userIdFromAddress(parsed.event.creatorAddress),
+                    channelId: streamId,
+                    reaction: payload.value.reaction,
+                    messageId: payload.value.refEventId,
+                });
+                this.emitter.emit('reaction', this.client, {
+                    ...createBasePayload(userIdFromAddress(parsed.event.creatorAddress), streamId, parsed.hashStr, createdAt, parsed.event, user),
+                    reaction: payload.value.reaction,
+                    messageId: payload.value.refEventId,
+                });
+                break;
+            }
+            case 'edit': {
+                // TODO: framework doesnt handle non-text edits
+                if (payload.value.post?.content.case !== 'text')
+                    break;
+                const mentions = parseMentions(payload.value.post?.content.value.mentions);
+                const isMentioned = mentions.some((m) => m.userId.toLowerCase() === this.agentUserId.toLowerCase());
+                debug('emit:messageEdit', {
+                    userId: userIdFromAddress(parsed.event.creatorAddress),
+                    channelId: streamId,
+                    refEventId: payload.value.refEventId,
+                    messagePreview: payload.value.post?.content.value.body.substring(0, 50),
+                    isMentioned,
+                });
+                this.emitter.emit('messageEdit', this.client, {
+                    ...createBasePayload(userIdFromAddress(parsed.event.creatorAddress), streamId, parsed.hashStr, createdAt, parsed.event, user),
+                    refEventId: payload.value.refEventId,
+                    message: payload.value.post?.content.value.body,
+                    mentions,
+                    isMentioned,
+                    replyId: payload.value.post?.replyId,
+                    threadId: payload.value.post?.threadId,
+                });
+                break;
+            }
+            case 'redaction': {
+                debug('emit:redaction', {
+                    userId: userIdFromAddress(parsed.event.creatorAddress),
+                    channelId: streamId,
+                    refEventId: payload.value.refEventId,
+                });
+                this.emitter.emit('redaction', this.client, {
+                    ...createBasePayload(userIdFromAddress(parsed.event.creatorAddress), streamId, parsed.hashStr, createdAt, parsed.event, user),
+                    refEventId: payload.value.refEventId,
+                });
+                break;
+            }
+            default:
+                logNever(payload);
+        }
+    }
+    async handlePaymentResponse(handler, event) {
+        if (!this.paymentConfig)
+            return;
+        const { response, channelId } = event;
+        // Check if this is a signature response
+        if (response.payload?.content?.case !== 'signature') {
+            return;
+        }
+        const signatureId = response.payload.content.value?.requestId ?? '';
+        const signature = (response.payload.content.value?.signature ?? '');
+        if (!signatureId || !signature) {
+            return;
+        }
+        // Check if this is a pending payment
+        const pending = this.pendingPayments.get(signatureId);
+        if (!pending) {
+            return; // Not a payment signature
+        }
+        // Remove from pending
+        this.pendingPayments.delete(signatureId);
+        const facilitator = useFacilitator(this.paymentConfig);
+        // Build PaymentPayload for x402
+        const paymentPayload = {
+            x402Version: 1,
+            scheme: 'exact',
+            network: chainIdToNetwork(this.viem.chain.id),
+            payload: {
+                signature: signature,
+                authorization: {
+                    from: pending.params.from,
+                    to: pending.params.to,
+                    value: pending.params.value.toString(),
+                    validAfter: pending.params.validAfter.toString(),
+                    validBefore: pending.params.validBefore.toString(),
+                    nonce: pending.params.nonce,
+                },
+            },
+        };
+        // Build PaymentRequirements for x402
+        const paymentRequirements = {
+            scheme: 'exact',
+            network: paymentPayload.network,
+            maxAmountRequired: pending.params.value.toString(),
+            resource: `https://towns.com/command/${pending.command}`,
+            description: `Payment for /${pending.command}`,
+            mimeType: 'application/json',
+            payTo: pending.params.to,
+            maxTimeoutSeconds: 300,
+            asset: pending.params.verifyingContract,
+        };
+        // Single status message that gets updated through the flow
+        const statusMsg = await handler.sendMessage(channelId, '🔍 Verifying payment...');
+        // Track settlement state to distinguish payment failures from post-payment failures
+        let settlementCompleted = false;
+        let transactionHash;
+        try {
+            const verifyResult = await facilitator.verify(paymentPayload, paymentRequirements);
+            if (!verifyResult.isValid) {
+                await handler.editMessage(channelId, statusMsg.eventId, `❌ Payment verification failed: ${verifyResult.invalidReason || 'Unknown error'}`);
+                await handler.removeEvent(channelId, pending.interactionEventId);
+                return;
+            }
+            // Update status: settling
+            await handler.editMessage(channelId, statusMsg.eventId, `✅ Verified • Settling $${formatUnits(pending.params.value, 6)} USDC...`);
+            const settleResult = await facilitator.settle(paymentPayload, paymentRequirements);
+            if (!settleResult.success) {
+                await handler.editMessage(channelId, statusMsg.eventId, `❌ Settlement failed: ${settleResult.errorReason || 'Unknown error'}`);
+                await handler.removeEvent(channelId, pending.interactionEventId);
+                return;
+            }
+            // Mark settlement as complete - funds have been transferred
+            settlementCompleted = true;
+            transactionHash = settleResult.transaction;
+            // Final success - show receipt
+            await handler.editMessage(channelId, statusMsg.eventId, `✅ **Payment Complete**\n` +
+                `/${pending.command} • $${formatUnits(pending.params.value, 6)} USDC\n` +
+                `Tx: \`${transactionHash}\``);
+            // Delete the signature request now that payment is complete
+            await handler.removeEvent(channelId, pending.interactionEventId);
+            // Execute the original command handler (stored with __paid_ prefix)
+            const actualHandlerKey = `__paid_${pending.command}`;
+            const originalHandler = this.slashCommandHandlers.get(actualHandlerKey);
+            if (originalHandler) {
+                await originalHandler(this.client, pending.event);
+            }
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+            if (settlementCompleted) {
+                // Payment succeeded but command handler failed - DO NOT suggest retry
+                await handler.editMessage(channelId, statusMsg.eventId, `⚠️ **Payment succeeded but command failed**\n` +
+                    `Your payment of $${formatUnits(pending.params.value, 6)} USDC was processed.\n` +
+                    `Tx: \`${transactionHash}\`\n\n` +
+                    `Error: ${errorMessage}\n` +
+                    `Please contact support - do NOT retry to avoid double charges.`);
+                // Don't remove interaction event - payment already processed
+            }
+            else {
+                // Actual payment failure (verify or settle threw)
+                await handler.editMessage(channelId, statusMsg.eventId, `❌ Payment failed: ${errorMessage}`);
+                await handler.removeEvent(channelId, pending.interactionEventId);
+            }
+        }
+    }
+    /**
+     * get the public device key of the agent
+     * @returns the public device key of the agent
+     */
+    getUserDevice() {
+        return this.client.crypto.getUserDevice();
+    }
+    /**
+     * Send a message to a stream
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param message - The cleartext of the message
+     * @param opts - The options for the message
+     */
+    async sendMessage(streamId, message, opts) {
+        const result = await this.client.sendMessage(streamId, message, opts, this.currentMessageTags);
+        this.currentMessageTags = undefined;
+        return result;
+    }
+    /**
+     * Send a reaction to a stream
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param refEventId - The eventId of the event to react to
+     * @param reaction - The reaction to send
+     */
+    async sendReaction(streamId, refEventId, reaction) {
+        const result = await this.client.sendReaction(streamId, refEventId, reaction, this.currentMessageTags);
+        this.currentMessageTags = undefined;
+        return result;
+    }
+    /**
+     * Remove an specific event from a stream
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param refEventId - The eventId of the event to remove
+     */
+    async removeEvent(streamId, refEventId) {
+        const result = await this.client.removeEvent(streamId, refEventId, this.currentMessageTags);
+        this.currentMessageTags = undefined;
+        return result;
+    }
+    /**
+     * Add a user (or app) to a stream via user membership action.
+     * Requires the agent to already be a member of the stream.
+     * @param streamId - Id of the stream to join (channel, space, gdm)
+     * @param userId - User ID to add
+     */
+    async joinUser(streamId, userId) {
+        return this.client.sendEvent(makeUserStreamId(this.agentUserId), make_UserPayload_UserMembershipAction({
+            op: MembershipOp.SO_JOIN,
+            userId: addressFromUserId(userId),
+            streamId: streamIdAsBytes(streamId),
+        }));
+    }
+    /**
+     * Edit an specific message from a stream
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param messageId - The eventId of the message to edit
+     * @param message - The new message text
+     */
+    async editMessage(streamId, messageId, message, opts) {
+        const result = await this.client.editMessage(streamId, messageId, message, opts, this.currentMessageTags);
+        this.currentMessageTags = undefined;
+        return result;
+    }
+    /**
+     * Send a GM (generic message) to a stream with schema validation
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param typeUrl - The type URL identifying the message format
+     * @param schema - StandardSchema for validation
+     * @param data - Data to validate and send
+     */
+    async sendGM(streamId, typeUrl, schema, data, opts) {
+        const result = await this.client.sendGM(streamId, typeUrl, schema, data, opts, this.currentMessageTags);
+        this.currentMessageTags = undefined;
+        return result;
+    }
+    /**
+     * Send a raw GM (generic message) to a stream without schema validation
+     * @param streamId - Id of the stream. Usually channelId or userId
+     * @param typeUrl - The type URL identifying the message format
+     * @param message - Optional raw message data as bytes
+     * @param opts - The options for the message
+     */
+    async sendRawGM(streamId, typeUrl, message, opts) {
+        const result = await this.client.sendRawGM(streamId, typeUrl, message, opts, this.currentMessageTags);
+        this.currentMessageTags = undefined;
+        return result;
+    }
+    /**
+     * Send a conversation seed to a stream
+     * @param streamId - Id of the stream. Usually channelId
+     * @param seed - The conversation seed payload
+     * @param opts - The options for the message
+     */
+    async sendConversationSeed(streamId, seed, opts) {
+        const result = await this.client.sendConversationSeed(streamId, seed, opts, this.currentMessageTags);
+        this.currentMessageTags = undefined;
+        return result;
+    }
+    // Implementation
+    async sendInteractionRequest(streamId, contentOrPayload, recipientOrOpts, maybeOpts) {
+        const tags = this.currentMessageTags;
+        this.currentMessageTags = undefined;
+        if (isFlattenedRequest(contentOrPayload)) {
+            // New flattened format: (streamId, payload, opts?)
+            return this.client.sendInteractionRequest(streamId, contentOrPayload, recipientOrOpts, tags);
+        }
+        else {
+            // Old format: (streamId, content, recipient?, opts?)
+            return this.client.sendInteractionRequest(streamId, contentOrPayload, recipientOrOpts, maybeOpts, tags);
+        }
+    }
+    /**
+     * Send an AddMember interaction request to add a user to a GDM
+     * @param streamId - Id of the GDM stream
+     * @param userId - The user ID to add to the GDM
+     * @param opts - Optional message and other options
+     * @returns The eventId and requestId of the interaction request
+     */
+    async sendAddMemberRequest(streamId, userId, opts) {
+        const { message, ...messageOpts } = opts ?? {};
+        return this.sendInteractionRequest(streamId, {
+            type: 'addMember',
+            userId,
+            message,
+        }, messageOpts);
+    }
+    async pinMessage(streamId, eventId, streamEvent) {
+        return this.client.pinMessage(streamId, eventId, streamEvent);
+    }
+    async unpinMessage(streamId, eventId) {
+        return this.client.unpinMessage(streamId, eventId);
+    }
+    /** Sends a tip to a user by looking up their smart account.
+     *  Tip will always get funds from the app account balance.
+     * @param params - Tip parameters including userId, amount, messageId, channelId, currency.
+     * @returns The transaction hash and event ID
+     */
+    async sendTip(params) {
+        const result = await this.client.sendTip(params, this.currentMessageTags);
+        this.currentMessageTags = undefined;
+        return result;
+    }
+    /**
+     * Triggered when someone sends a message.
+     * This is triggered for all messages, including direct messages and group messages.
+     */
+    onMessage(fn) {
+        return this.emitter.on('message', fn);
+    }
+    onRedaction(fn) {
+        return this.emitter.on('redaction', fn);
+    }
+    /**
+     * Triggered when a message gets edited
+     */
+    onMessageEdit(fn) {
+        return this.emitter.on('messageEdit', fn);
+    }
+    /**
+     * Triggered when someone reacts to a message
+     */
+    onReaction(fn) {
+        return this.emitter.on('reaction', fn);
+    }
+    /**
+     * Triggered when a message is revoked by a moderator
+     */
+    onEventRevoke(fn) {
+        return this.emitter.on('eventRevoke', fn);
+    }
+    /**
+     * Triggered when someone tips the agent
+     */
+    onTip(fn) {
+        return this.emitter.on('tip', fn);
+    }
+    /**
+     * Triggered when someone joins a channel
+     */
+    onChannelJoin(fn) {
+        return this.emitter.on('channelJoin', fn);
+    }
+    /**
+     * Triggered when someone leaves a channel
+     */
+    onChannelLeave(fn) {
+        return this.emitter.on('channelLeave', fn);
+    }
+    onStreamEvent(fn) {
+        return this.emitter.on('streamEvent', fn);
+    }
+    onSlashCommand(command, fn) {
+        const paymentConfig = this.paymentCommands.get(command);
+        if (!paymentConfig || !this.paymentConfig) {
+            this.slashCommandHandlers.set(command, fn);
+            const unset = () => {
+                if (this.slashCommandHandlers.has(command) &&
+                    this.slashCommandHandlers.get(command) === fn) {
+                    this.slashCommandHandlers.delete(command);
+                }
+            };
+            return unset;
+        }
+        this.slashCommandHandlers.set(command, async (handler, event) => {
+            try {
+                const chainId = this.viem.chain.id;
+                const { signatureId, params, eventId } = await createPaymentRequest(handler, event, chainId, event.userId, this.appAddress, paymentConfig, command);
+                // Store pending payment
+                this.pendingPayments.set(signatureId, {
+                    command: command,
+                    channelId: event.channelId,
+                    userId: event.userId,
+                    interactionEventId: eventId,
+                    event: event,
+                    params: params,
+                });
+            }
+            catch (error) {
+                await handler.sendMessage(event.channelId, `❌ Failed to request payment: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            }
+        });
+        const actualHandlerKey = `__paid_${command}`;
+        this.slashCommandHandlers.set(actualHandlerKey, fn);
+        const unset = () => {
+            if (this.slashCommandHandlers.has(command) &&
+                this.slashCommandHandlers.get(command) === fn) {
+                this.slashCommandHandlers.delete(command);
+            }
+        };
+        return unset;
+    }
+    onCapability(name, fn) {
+        this.capabilityHandlers.set(name, fn);
+        return () => {
+            if (this.capabilityHandlers.get(name) === fn) {
+                this.capabilityHandlers.delete(name);
+            }
+        };
+    }
+    onPositions(handler) {
+        this.positionsHandler = handler;
+        return () => {
+            if (this.positionsHandler === handler) {
+                this.positionsHandler = undefined;
+            }
+        };
+    }
+    onConciergeRequest(fn) {
+        this.conciergeRequestHandler = fn;
+        return () => {
+            if (this.conciergeRequestHandler === fn) {
+                this.conciergeRequestHandler = undefined;
+            }
+        };
+    }
+    /**
+     * Triggered when someone sends a GM (generic message) with type validation using StandardSchema
+     * @param typeUrl - The type URL to listen for
+     * @param schema - The StandardSchema to validate the message data
+     * @param handler - The handler function to call when a message is received
+     */
+    onGmMessage(typeUrl, schema, handler) {
+        this.gmTypedHandlers.set(typeUrl, { schema, handler: handler });
+        const unset = () => {
+            if (this.gmTypedHandlers.has(typeUrl) &&
+                this.gmTypedHandlers.get(typeUrl)?.handler === handler) {
+                this.gmTypedHandlers.delete(typeUrl);
+            }
+        };
+        return unset;
+    }
+    onRawGmMessage(handler) {
+        return this.emitter.on('rawGmMessage', handler);
+    }
+    /**
+     * Triggered when someone sends an interaction response
+     * @param fn - The handler function to call when an interaction response is received
+     */
+    onInteractionResponse(fn) {
+        return this.emitter.on('interactionResponse', fn);
+    }
+    /**
+     * Triggered when someone sends a conversation seed response
+     */
+    onConversationSeedResponse(fn) {
+        return this.emitter.on('conversationSeedResponse', fn);
+    }
+    /**
+     * Triggered when a user selects a proposal that targets this bot.
+     * Only fires for selectedProposal responses where targetAgentId matches this bot's appAddress.
+     */
+    onSelectedProposal(fn) {
+        return this.emitter.on('selectedProposal', fn);
+    }
+    /**
+     * Get the stream view for a stream
+     * Stream views contain contextual information about the stream (space, channel, etc)
+     * Stream views contain member data for all streams - you can iterate over all members in a channel via: `streamView.getMembers().joined.keys()`
+     * note: potentially expensive operation because streams can be large, fine to use in small streams
+     * @param streamId - The stream ID to get the view for
+     * @returns The stream view
+     */
+    async getStreamView(streamId) {
+        return this.client.getStream(streamId);
+    }
+    /**
+     * Get the ERC-8004 compliant metadata JSON
+     * This should be hosted at /.well-known/agent-metadata.json
+     * Merges cached app metadata with local identity config
+     * @returns The ERC-8004 compliant metadata object or null
+     */
+    async getIdentityMetadata() {
+        if (!this.identityConfig && !this.metadata.displayName)
+            return null;
+        const endpoints = [];
+        if (this.identityConfig?.endpoints) {
+            endpoints.push(...this.identityConfig.endpoints);
+        }
+        const hasAgentWallet = endpoints.some((e) => e.name === 'agentWallet');
+        if (!hasAgentWallet) {
+            const chainId = this.viem.chain.id;
+            endpoints.push({
+                name: 'agentWallet',
+                endpoint: `eip155:${chainId}:${this.appAddress}`,
+            });
+        }
+        const domain = this.identityConfig?.domain;
+        if (domain && !endpoints.some((e) => e.name === 'A2A')) {
+            const origin = domain.startsWith('http') ? domain : `https://${domain}`;
+            endpoints.push({
+                name: 'A2A',
+                endpoint: `${origin}/.well-known/agent-card.json`,
+                version: '0.3.0',
+            });
+        }
+        // Merge app metadata with identity config, preferring identity config
+        const name = this.identityConfig?.name || this.metadata.displayName || 'Unknown Agent';
+        const description = this.identityConfig?.description || this.metadata.description || '';
+        const image = this.identityConfig?.image || this.metadata.imageUrl || '';
+        const motto = this.identityConfig?.motto || this.metadata.motto;
+        return {
+            type: 'https://eips.ethereum.org/EIPS/eip-8004#registration-v1',
+            name,
+            description,
+            image,
+            endpoints,
+            registrations: this.identityConfig?.registrations || [],
+            supportedTrust: this.identityConfig?.supportedTrust,
+            motto,
+            capabilities: [
+                ...(this.commands?.map((c) => c.name) || []),
+                ...(this.capabilities?.map((c) => c.name) || []),
+            ],
+            version: packageJson.version,
+            framework: `javascript:${packageJson.name}:${packageJson.version}`,
+            attributes: this.identityConfig?.attributes,
+        };
+    }
+    /**
+     * Get the tokenURI that would be used for ERC-8004 registration
+     * Returns null if no domain is configured
+     * @returns The .well-known URL or null
+     */
+    getTokenURI() {
+        if (!this.identityConfig?.domain)
+            return null;
+        const origin = this.identityConfig.domain.startsWith('http')
+            ? this.identityConfig.domain
+            : `https://${this.identityConfig.domain}`;
+        return `${origin}/.well-known/agent-metadata.json`;
+    }
+}
+export const makeTownsApp = async (appPrivateData, opts = {}) => {
+    const { baseRpcUrl, jwtSecret: jwtSecretBase64, ...clientOpts } = opts;
+    let appAddress;
+    const { privateKey, encryptionDevice, env, appAddress: appAddressFromPrivateData, jwtSecret: jwtSecretFromPrivateData, } = parseAppPrivateData(appPrivateData);
+    const resolvedJwtSecret = jwtSecretBase64 || process.env.JWT_SECRET || jwtSecretFromPrivateData;
+    if (!resolvedJwtSecret) {
+        throw new Error('JWT secret is required: provide it via opts.jwtSecret or the JWT_SECRET environment variable');
+    }
+    if (!env) {
+        throw new Error('Failed to parse APP_PRIVATE_DATA');
+    }
+    if (appAddressFromPrivateData) {
+        appAddress = appAddressFromPrivateData;
+    }
+    const account = privateKeyToAccount(privateKey);
+    const baseConfig = townsEnv().makeBaseChainConfig(env);
+    const getChain = (chainId) => {
+        if (chainId === base.id)
+            return base;
+        if (chainId === foundry.id)
+            return foundry;
+        return baseSepolia;
+    };
+    const chain = getChain(baseConfig.chainConfig.chainId);
+    const viem = createWalletClient({
+        account,
+        transport: baseRpcUrl
+            ? http(baseRpcUrl, { batch: true })
+            : http(baseConfig.rpcUrl, { batch: true }),
+        chain,
+    });
+    if (!appAddress) {
+        appAddress = await readContract(viem, {
+            address: baseConfig.chainConfig.addresses.appRegistry,
+            abi: appRegistryAbi,
+            functionName: 'getAppByClient',
+            args: [account.address],
+        });
+    }
+    const client = await createTownsClient({
+        privateKey,
+        env,
+        encryptionDevice: {
+            fromExportedDevice: encryptionDevice,
+        },
+        ...clientOpts,
+    }).then((x) => x.extend((townsClient) => buildAgentActions(townsClient, viem, appAddress)));
+    {
+        const updateMask = [];
+        const metadata = {};
+        if (opts.commands) {
+            updateMask.push('slash_commands');
+            metadata.slashCommands = opts.commands;
+        }
+        if (opts.capabilities) {
+            updateMask.push('capabilities');
+            metadata.capabilities = opts.capabilities.map((cap) => ({
+                name: cap.name,
+                description: cap.description,
+                inputSchema: extractJsonSchema(cap.input),
+                examples: cap.examples?.map((ex) => ({
+                    userQuery: ex.userQuery,
+                    parameters: ex.parameters,
+                })) ?? [],
+            }));
+        }
+        if (updateMask.length > 0) {
+            client
+                .appServiceClient()
+                .then((appRegistryClient) => appRegistryClient
+                .updateAppMetadata({
+                appId: bin_fromHexString(account.address),
+                updateMask,
+                metadata,
+            })
+                .catch((err) => {
+                // eslint-disable-next-line no-console
+                console.warn('[@towns-labs/app-framework] failed to update app metadata', err);
+            }))
+                .catch((err) => {
+                // eslint-disable-next-line no-console
+                console.warn('[@towns-labs/app-framework] failed to get app registry rpc client', err);
+            });
+        }
+    }
+    await client.uploadDeviceKeys();
+    let appMetadata;
+    try {
+        const appRegistry = await client.appServiceClient();
+        const response = await appRegistry.getAppMetadata({
+            appId: bin_fromHexString(account.address),
+        });
+        appMetadata = response.metadata;
+    }
+    catch (err) {
+        // eslint-disable-next-line no-console
+        console.warn('[@towns-labs/app-framework] Failed to fetch app metadata', err);
+    }
+    return new App(client, viem, resolvedJwtSecret, appAddress, opts.commands, opts.capabilities, opts.identity, opts.dedup, opts.paymentConfig, appMetadata);
+};
+function extractJsonSchema(schema) {
+    try {
+        return JSON.stringify(schema['~standard'].jsonSchema.input({ target: 'draft-2020-12' }));
+    }
+    catch (error) {
+        try {
+            return JSON.stringify(schema['~standard'].jsonSchema.input({ target: 'draft-07' }));
+        }
+        catch (fallbackError) {
+            throw new Error('extractJsonSchema: schema["~standard"].jsonSchema.input() failed for both draft-2020-12 and draft-07 targets', { cause: { draft202012Error: error, draft07Error: fallbackError } });
+        }
+    }
+}
+const buildAgentActions = (client, viem, appAddress) => {
+    const CHUNK_SIZE = 1200000; // 1.2MB max per chunk (including auth tag)
+    const createChunkedMediaAttachment = async (attachment) => {
+        let data;
+        let mimetype;
+        if (attachment.data instanceof Blob) {
+            const buffer = await attachment.data.arrayBuffer();
+            data = new Uint8Array(buffer);
+            mimetype = attachment.data.type;
+        }
+        else {
+            data = attachment.data;
+            if ('mimetype' in attachment) {
+                mimetype = attachment.mimetype;
+            }
+            else {
+                throw new Error('mimetype is required for Uint8Array data');
+            }
+        }
+        let width = attachment.width || 0;
+        let height = attachment.height || 0;
+        if (mimetype.startsWith('image/') && (!width || !height)) {
+            const dimensions = imageSize(data);
+            width = dimensions.width || 0;
+            height = dimensions.height || 0;
+        }
+        const { chunks, secretKey } = await encryptChunkedAESGCM(data, CHUNK_SIZE);
+        const chunkCount = chunks.length;
+        if (chunkCount === 0) {
+            throw new Error('No media chunks generated');
+        }
+        // TODO: Implement thumbnail generation with sharp
+        const thumbnail = undefined;
+        const streamId = makeUniqueMediaStreamId();
+        const events = await Promise.all([
+            makeEvent(client.signerContext, make_MediaPayload_Inception({
+                streamId: streamIdAsBytes(streamId),
+                userId: addressFromUserId(client.userId),
+                chunkCount,
+                perChunkEncryption: true,
+            })),
+            makeEvent(client.signerContext, make_MediaPayload_Chunk({
+                data: chunks[0].ciphertext,
+                chunkIndex: 0,
+                iv: chunks[0].iv,
+            })),
+        ]);
+        const mediaStreamResponse = await client.rpc.createMediaStream({
+            events,
+            streamId: streamIdAsBytes(streamId),
+        });
+        if (!mediaStreamResponse?.nextCreationCookie) {
+            throw new Error('Failed to create media stream');
+        }
+        if (chunkCount > 1) {
+            let cc = create(CreationCookieSchema, mediaStreamResponse.nextCreationCookie);
+            for (let chunkIndex = 1; chunkIndex < chunkCount; chunkIndex++) {
+                const chunkEvent = await makeEvent(client.signerContext, make_MediaPayload_Chunk({
+                    data: chunks[chunkIndex].ciphertext,
+                    chunkIndex: chunkIndex,
+                    iv: chunks[chunkIndex].iv,
+                }), cc.prevMiniblockHash);
+                const result = await client.rpc.addMediaEvent({
+                    event: chunkEvent,
+                    creationCookie: cc,
+                    last: chunkIndex === chunkCount - 1,
+                });
+                if (!result?.creationCookie) {
+                    throw new Error('Failed to send media chunk');
+                }
+                cc = create(CreationCookieSchema, result.creationCookie);
+            }
+        }
+        const mediaStreamInfo = { creationCookie: mediaStreamResponse.nextCreationCookie };
+        return {
+            content: {
+                case: 'chunkedMedia',
+                value: create(ChunkedMediaSchema, {
+                    info: {
+                        filename: attachment.filename,
+                        mimetype: mimetype,
+                        widthPixels: width,
+                        heightPixels: height,
+                        sizeBytes: BigInt(data.length),
+                    },
+                    streamId: streamIdAsString(mediaStreamInfo.creationCookie.streamId),
+                    encryption: {
+                        case: 'aesgcm',
+                        value: {
+                            iv: new Uint8Array(0),
+                            secretKey: secretKey,
+                        },
+                    },
+                    thumbnail,
+                }),
+            },
+        };
+    };
+    const createImageAttachmentFromURL = async (attachment) => {
+        try {
+            const response = await fetch(attachment.url);
+            if (!response.ok) {
+                return null;
+            }
+            const contentType = response.headers.get('content-type');
+            if (!contentType || !contentType.startsWith('image/')) {
+                // eslint-disable-next-line no-console
+                console.warn(`A non-image URL attachment was provided. ${attachment.url} (Content-Type: ${contentType || 'unknown'})`);
+                return null;
+            }
+            const bytes = await response.bytes();
+            const dimensions = imageSize(bytes);
+            const width = dimensions.width || 0;
+            const height = dimensions.height || 0;
+            const image = create(ChannelMessage_Post_Content_ImageSchema, {
+                title: attachment.alt || '',
+                info: create(ChannelMessage_Post_Content_Image_InfoSchema, {
+                    url: attachment.url,
+                    mimetype: contentType,
+                    width,
+                    height,
+                }),
+            });
+            return {
+                content: {
+                    case: 'image',
+                    value: image,
+                },
+            };
+        }
+        catch {
+            return null;
+        }
+    };
+    const createLinkAttachment = (attachment) => {
+        return create(ChannelMessage_Post_AttachmentSchema, {
+            content: {
+                case: 'unfurledUrl',
+                value: {
+                    url: attachment.url,
+                    image: attachment.image,
+                    title: attachment.title ?? '',
+                    description: attachment.description ?? '',
+                },
+            },
+        });
+    };
+    const createTickerAttachment = (attachment) => {
+        return create(ChannelMessage_Post_AttachmentSchema, {
+            content: {
+                case: 'ticker',
+                value: {
+                    address: attachment.address,
+                    chainId: attachment.chainId,
+                },
+            },
+        });
+    };
+    const createMiniAppAttachment = (attachment) => {
+        return create(ChannelMessage_Post_AttachmentSchema, {
+            content: {
+                case: 'miniapp',
+                value: { url: attachment.url },
+            },
+        });
+    };
+    const mapIcon = (icon) => {
+        if (!icon)
+            return undefined;
+        switch (icon) {
+            case 'check':
+                return ChannelMessage_Post_Content_InfoCard_Label_Icon.CHECK;
+            case 'x':
+                return ChannelMessage_Post_Content_InfoCard_Label_Icon.X;
+            case 'warning':
+                return ChannelMessage_Post_Content_InfoCard_Label_Icon.WARNING;
+            case 'info':
+                return ChannelMessage_Post_Content_InfoCard_Label_Icon.INFO;
+        }
+    };
+    const mapBadgeVariant = (variant) => {
+        if (!variant)
+            return undefined;
+        switch (variant) {
+            case 'positive':
+                return ChannelMessage_Post_Content_InfoCard_Label_Badge_Variant.POSITIVE;
+            case 'negative':
+                return ChannelMessage_Post_Content_InfoCard_Label_Badge_Variant.NEGATIVE;
+        }
+    };
+    const createInfoCardAttachment = (attachment) => {
+        const title = create(ChannelMessage_Post_Content_InfoCard_LabelSchema, {
+            icon: mapIcon(attachment.title.icon),
+            text: attachment.title.text,
+            badge: attachment.title.badge
+                ? {
+                    text: attachment.title.badge.text,
+                    variant: mapBadgeVariant(attachment.title.badge.variant),
+                }
+                : undefined,
+        });
+        const fields = attachment.fields.map((field) => {
+            let value;
+            switch (field.value.type) {
+                case 'text':
+                    value = {
+                        case: 'text',
+                        value: create(ChannelMessage_Post_Content_InfoCard_LabelSchema, {
+                            icon: mapIcon(field.value.icon),
+                            text: field.value.text,
+                            badge: field.value.badge
+                                ? {
+                                    text: field.value.badge.text,
+                                    variant: mapBadgeVariant(field.value.badge.variant),
+                                }
+                                : undefined,
+                        }),
+                    };
+                    break;
+                case 'user':
+                    value = {
+                        case: 'user',
+                        value: create(ChannelMessage_Post_Content_InfoCard_UserRefSchema, {
+                            userId: field.value.userId,
+                        }),
+                    };
+                    break;
+                case 'token':
+                    value = {
+                        case: 'token',
+                        value: create(ChannelMessage_Post_Content_InfoCard_TokenAmountSchema, {
+                            chainId: field.value.chainId,
+                            address: field.value.address,
+                            amount: field.value.amount,
+                        }),
+                    };
+                    break;
+                case 'contract':
+                    value = {
+                        case: 'contract',
+                        value: create(ChannelMessage_Post_Content_InfoCard_ContractRefSchema, {
+                            chainId: field.value.chainId,
+                            address: field.value.address,
+                        }),
+                    };
+                    break;
+                case 'marketItem':
+                    value = {
+                        case: 'marketItem',
+                        value: create(ChannelMessage_Post_Content_InfoCard_MarketItemSchema, {
+                            name: field.value.name,
+                            price: field.value.price,
+                            iconUrl: field.value.iconUrl,
+                            subtitle: field.value.subtitle,
+                            change: field.value.change,
+                            changePct: field.value.changePct,
+                            direction: mapBadgeVariant(field.value.direction),
+                            outcomes: field.value.outcomes?.map((o) => create(ChannelMessage_Post_Content_InfoCard_MarketItem_OutcomeSchema, {
+                                label: o.label,
+                                value: o.value,
+                                variant: mapBadgeVariant(o.variant),
+                            })) ?? [],
+                        }),
+                    };
+                    break;
+            }
+            return create(ChannelMessage_Post_Content_InfoCard_FieldSchema, {
+                label: field.label,
+                value,
+            });
+        });
+        return create(ChannelMessage_Post_AttachmentSchema, {
+            content: {
+                case: 'infoCard',
+                value: create(ChannelMessage_Post_Content_InfoCardSchema, {
+                    title,
+                    fields,
+                }),
+            },
+        });
+    };
+    const ensureOutboundSession = async (streamId, encryptionAlgorithm, toUserIds, miniblockInfo) => {
+        if (!(await client.crypto.hasOutboundSession(streamId, encryptionAlgorithm))) {
+            // ATTEMPT 1: Get session from app service
+            const appService = await client.appServiceClient();
+            try {
+                const sessionResp = await appService.getSession({
+                    appId: userIdToAddress(client.userId),
+                    identifier: {
+                        case: 'streamId',
+                        value: streamIdAsBytes(streamId),
+                    },
+                });
+                if (sessionResp.groupEncryptionSessions) {
+                    const parsedEvent = await unpackEnvelope(sessionResp.groupEncryptionSessions, client.unpackEnvelopeOpts);
+                    check(parsedEvent.event.payload.case === 'userInboxPayload' &&
+                        parsedEvent.event.payload.value.content.case ===
+                            'groupEncryptionSessions', 'invalid event payload');
+                    await client.importGroupEncryptionSessions({
+                        streamId,
+                        sessions: parsedEvent.event.payload.value.content.value,
+                    });
+                    // EARLY RETURN
+                    return;
+                }
+            }
+            catch {
+                // ignore error (should log)
+            }
+            // ATTEMPT 2: Create new session
+            await client.crypto.ensureOutboundSession(streamId, encryptionAlgorithm, {
+                shareShareSessionTimeoutMs: 5000,
+                priorityUserIds: [client.userId, ...toUserIds],
+                miniblockInfo,
+            });
+        }
+    };
+    const sendMessageEvent = async ({ streamId, payload, tags, ephemeral, }) => {
+        const miniblockInfo = await client.getMiniblockInfo(streamId);
+        const eventTags = {
+            ...unsafe_makeTags(payload),
+            participatingUserAddresses: tags?.participatingUserAddresses || [],
+            threadId: tags?.threadId || undefined,
+        };
+        const encryptionAlgorithm = miniblockInfo.encryptionAlgorithm?.algorithm
+            ? miniblockInfo.encryptionAlgorithm.algorithm
+            : client.defaultGroupEncryptionAlgorithm;
+        await ensureOutboundSession(streamId, encryptionAlgorithm, Array.from(new Set([
+            ...eventTags.participatingUserAddresses.map((x) => userIdFromAddress(x)),
+            ...eventTags.mentionedUserAddresses.map((x) => userIdFromAddress(x)),
+        ])), miniblockInfo);
+        const message = await client.crypto.encryptGroupEvent(streamId, toBinary(ChannelMessageSchema, payload), encryptionAlgorithm);
+        message.refEventId = getRefEventIdFromChannelMessage(payload);
+        if (!isGDMChannelStreamId(streamId)) {
+            throw new Error(`Invalid stream ID type for channel message: ${streamId}`);
+        }
+        const eventPayload = make_GDMChannelPayload_Message(message);
+        return client.sendEvent(streamId, eventPayload, eventTags, ephemeral);
+    };
+    const sendKeySolicitation = async (streamId, sessionIds) => {
+        const encryptionDevice = client.crypto.getUserDevice();
+        const missingSessionIds = sessionIds.filter((sessionId) => sessionId !== '');
+        return client.sendEvent(streamId, make_MemberPayload_KeySolicitation({
+            deviceKey: encryptionDevice.deviceKey,
+            fallbackKey: encryptionDevice.fallbackKey,
+            isNewDevice: missingSessionIds.length === 0,
+            sessionIds: missingSessionIds,
+        }));
+    };
+    const uploadDeviceKeys = async () => {
+        const streamId = makeUserMetadataStreamId(client.userId);
+        const encryptionDevice = client.crypto.getUserDevice();
+        return client.sendEvent(streamId, make_UserMetadataPayload_EncryptionDevice({
+            ...encryptionDevice,
+        }));
+    };
+    const sendMessage = async (streamId, message, opts, tags) => {
+        const processedAttachments = [];
+        if (opts?.attachments && opts.attachments.length > 0) {
+            for (const attachment of opts.attachments) {
+                switch (attachment.type) {
+                    case 'image': {
+                        const result = await createImageAttachmentFromURL(attachment);
+                        processedAttachments.push(result);
+                        break;
+                    }
+                    case 'chunked': {
+                        const result = await createChunkedMediaAttachment(attachment);
+                        processedAttachments.push(result);
+                        break;
+                    }
+                    case 'link': {
+                        const result = createLinkAttachment(attachment);
+                        processedAttachments.push(result);
+                        break;
+                    }
+                    case 'ticker': {
+                        const result = createTickerAttachment(attachment);
+                        processedAttachments.push(result);
+                        break;
+                    }
+                    case 'miniapp': {
+                        const result = createMiniAppAttachment(attachment);
+                        processedAttachments.push(result);
+                        break;
+                    }
+                    case 'infoCard': {
+                        const result = createInfoCardAttachment(attachment);
+                        processedAttachments.push(result);
+                        break;
+                    }
+                    default:
+                        logNever(attachment);
+                }
+            }
+        }
+        const payload = create(ChannelMessageSchema, {
+            payload: {
+                case: 'post',
+                value: {
+                    threadId: opts?.threadId,
+                    replyId: opts?.replyId,
+                    replyPreview: opts?.replyId ? '🙈' : undefined,
+                    threadPreview: opts?.threadId ? '🙉' : undefined,
+                    content: {
+                        case: 'text',
+                        value: {
+                            body: message,
+                            attachments: processedAttachments.filter((x) => x !== null),
+                            mentions: processMentions(opts?.mentions),
+                        },
+                    },
+                },
+            },
+        });
+        return sendMessageEvent({ streamId, payload, tags, ephemeral: opts?.ephemeral });
+    };
+    const editMessage = async (streamId, messageId, message, opts, tags) => {
+        const processedAttachments = [];
+        if (opts?.attachments && opts.attachments.length > 0) {
+            for (const attachment of opts.attachments) {
+                switch (attachment.type) {
+                    case 'image': {
+                        const result = await createImageAttachmentFromURL(attachment);
+                        processedAttachments.push(result);
+                        break;
+                    }
+                    case 'chunked': {
+                        const result = await createChunkedMediaAttachment(attachment);
+                        processedAttachments.push(result);
+                        break;
+                    }
+                    case 'link': {
+                        const result = createLinkAttachment(attachment);
+                        processedAttachments.push(result);
+                        break;
+                    }
+                    case 'ticker': {
+                        const result = createTickerAttachment(attachment);
+                        processedAttachments.push(result);
+                        break;
+                    }
+                    case 'miniapp': {
+                        const result = createMiniAppAttachment(attachment);
+                        processedAttachments.push(result);
+                        break;
+                    }
+                    case 'infoCard': {
+                        const result = createInfoCardAttachment(attachment);
+                        processedAttachments.push(result);
+                        break;
+                    }
+                    default:
+                        logNever(attachment);
+                }
+            }
+        }
+        const payload = create(ChannelMessageSchema, {
+            payload: {
+                case: 'edit',
+                value: {
+                    refEventId: messageId,
+                    post: {
+                        threadId: opts?.threadId,
+                        replyId: opts?.replyId,
+                        replyPreview: opts?.replyId ? '🙈' : undefined,
+                        threadPreview: opts?.threadId ? '🙉' : undefined,
+                        content: {
+                            case: 'text',
+                            value: {
+                                body: message,
+                                mentions: processMentions(opts?.mentions),
+                                attachments: processedAttachments.filter((x) => x !== null),
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        return sendMessageEvent({ streamId, payload, tags, ephemeral: opts?.ephemeral });
+    };
+    const sendReaction = async (streamId, messageId, reaction, tags) => {
+        const payload = create(ChannelMessageSchema, {
+            payload: { case: 'reaction', value: { refEventId: messageId, reaction } },
+        });
+        return sendMessageEvent({ streamId, payload, tags });
+    };
+    /**
+     * Used to send a typed message into a channel stream.
+     * The message will be serialized to JSON using superjson and then encoded to bytes.
+     * Clients can agree on the schema to deserialize the message by the typeUrl.
+     * @param streamId - The stream ID to send the message to.
+     * @param typeUrl - A schema type URL for the message
+     * @param message - The message to send as raw bytes.
+     * @param tags - The tags to send with the message.
+     * @returns The event ID of the sent message.
+     */
+    async function sendGM(streamId, typeUrl, schema, data, opts, tags) {
+        const result = await schema['~standard'].validate(data);
+        if ('issues' in result && result.issues) {
+            throw new Error(`Schema validation failed: ${result.issues.map((issue) => issue.message).join(', ')}`);
+        }
+        const jsonString = superjsonStringify(result.value);
+        const jsonBytesMessage = new TextEncoder().encode(jsonString);
+        const payload = create(ChannelMessageSchema, {
+            payload: {
+                case: 'post',
+                value: {
+                    threadId: opts?.threadId,
+                    replyId: opts?.replyId,
+                    replyPreview: opts?.replyId ? '🙈' : undefined,
+                    threadPreview: opts?.threadId ? '🙉' : undefined,
+                    content: { case: 'gm', value: { typeUrl: typeUrl, value: jsonBytesMessage } },
+                },
+            },
+        });
+        return sendMessageEvent({ streamId, payload, tags, ephemeral: opts?.ephemeral });
+    }
+    /**
+     * Used to send a custom message into a channel stream.
+     * The messages will be a raw bytes.
+     * Clients can agree on the schema to deserialize the message by the typeUrl.
+     * @param streamId - The stream ID to send the message to.
+     * @param typeUrl - A schema type URL for the message
+     * @param message - The message to send as raw bytes.
+     * @param tags - The tags to send with the message.
+     * @returns The event ID of the sent message.
+     */
+    const sendRawGM = async (streamId, typeUrl, message, opts, tags) => {
+        const payload = create(ChannelMessageSchema, {
+            payload: {
+                case: 'post',
+                value: {
+                    threadId: opts?.threadId,
+                    replyId: opts?.replyId,
+                    replyPreview: opts?.replyId ? '🙈' : undefined,
+                    threadPreview: opts?.threadId ? '🙉' : undefined,
+                    content: { case: 'gm', value: { typeUrl: typeUrl, value: message } },
+                },
+            },
+        });
+        return sendMessageEvent({ streamId, payload, tags, ephemeral: opts?.ephemeral });
+    };
+    const sendConversationSeed = async (streamId, seed, opts, tags) => {
+        const payload = create(ChannelMessageSchema, {
+            payload: {
+                case: 'post',
+                value: {
+                    threadId: opts?.threadId,
+                    replyId: opts?.replyId,
+                    replyPreview: opts?.replyId ? '🙈' : undefined,
+                    threadPreview: opts?.threadId ? '🙉' : undefined,
+                    content: { case: 'conversationSeed', value: seed },
+                },
+            },
+        });
+        return sendMessageEvent({ streamId, payload, tags, ephemeral: opts?.ephemeral });
+    };
+    const removeEvent = async (streamId, messageId, tags) => {
+        const payload = create(ChannelMessageSchema, {
+            payload: { case: 'redaction', value: { refEventId: messageId } },
+        });
+        return sendMessageEvent({ streamId, payload, tags });
+    };
+    /**
+     * Pin a message to a stream
+     * @param streamId - The stream ID to pin the message to
+     * @param eventId - The event ID of the message to pin
+     * @param streamEvent - The stream event to pin
+     * @returns The event ID of the pinned message
+     */
+    const pinMessage = async (streamId, eventId, streamEvent) => {
+        return client.sendEvent(streamId, make_MemberPayload_Pin(bin_fromHexString(eventId), streamEvent));
+    };
+    /**
+     * Unpin a message from a stream
+     * @param streamId - The stream ID to unpin the message from
+     * @param eventId - The event ID of the message to unpin
+     * @returns The event ID of the unpinned message
+     */
+    const unpinMessage = async (streamId, eventId) => {
+        return client.sendEvent(streamId, make_MemberPayload_Unpin(bin_fromHexString(eventId)));
+    };
+    const getChannelSettings = async (_channelId) => {
+        throw new Error('Channel settings are not supported for GDM streams');
+    };
+    // Implementation
+    async function sendInteractionRequest(streamId, contentOrPayload, recipientOrOpts, optsOrTags, maybeTags) {
+        // Detect which format is being used
+        let content;
+        let recipient;
+        let opts;
+        let tags;
+        let requestId;
+        if (isFlattenedRequest(contentOrPayload)) {
+            // New flattened format
+            const result = flattenedToPayloadContent(contentOrPayload);
+            content = result.content;
+            requestId = result.requestId;
+            recipient = contentOrPayload.recipient
+                ? bin_fromHexString(contentOrPayload.recipient)
+                : undefined;
+            opts = recipientOrOpts;
+            tags = optsOrTags;
+        }
+        else {
+            // Old format
+            content = contentOrPayload;
+            requestId = content.value?.id ?? crypto.randomUUID();
+            if (content.value && content.value.id !== requestId) {
+                content.value.id = requestId;
+            }
+            recipient = recipientOrOpts;
+            opts = optsOrTags;
+            tags = maybeTags;
+        }
+        // Get encryption settings (same as sendMessageEvent)
+        const miniblockInfo = await client.getMiniblockInfo(streamId);
+        const encryptionAlgorithm = miniblockInfo.encryptionAlgorithm?.algorithm
+            ? miniblockInfo.encryptionAlgorithm.algorithm
+            : client.defaultGroupEncryptionAlgorithm;
+        await ensureOutboundSession(streamId, encryptionAlgorithm, recipient ? [userIdFromAddress(recipient)] : [], miniblockInfo);
+        // Create payload with content and encryption device for response
+        const payload = create(InteractionRequestPayloadSchema, {
+            encryptionDevice: client.crypto.getUserDevice(),
+            content: content,
+        });
+        // Encrypt using group encryption (same as messages)
+        const encryptedData = await client.crypto.encryptGroupEvent(streamId, toBinary(InteractionRequestPayloadSchema, payload), encryptionAlgorithm);
+        // Create the request matching InteractionResponse structure
+        const request = {
+            recipient: recipient,
+            encryptedData: encryptedData,
+            threadId: opts?.threadId ? bin_fromHexString(opts.threadId) : undefined,
+        };
+        // Send as InteractionRequest
+        const eventPayload = make_payload_InteractionRequest(streamId, request);
+        const { eventId } = await client.sendEvent(streamId, eventPayload, tags, opts?.ephemeral);
+        return { eventId, requestId };
+    }
+    /**
+     * Send a blockchain transaction to the stream
+     * @param streamId - The stream ID to send the transaction to
+     * @param chainId - The chain ID where the transaction occurred
+     * @param receipt - The transaction receipt from the blockchain
+     * @param content - The transaction content (tip, transfer, etc.)
+     * @returns The transaction hash and event ID
+     */
+    const sendBlockchainTransaction = async (chainId, receipt, content, tags) => {
+        const transaction = create(BlockchainTransactionSchema, {
+            receipt: {
+                chainId: BigInt(chainId),
+                transactionHash: bin_fromHexString(receipt.transactionHash),
+                blockNumber: receipt.blockNumber,
+                to: bin_fromHexString(receipt.to || zeroAddress),
+                from: bin_fromHexString(receipt.from),
+                logs: receipt.logs.map((log) => ({
+                    address: bin_fromHexString(log.address),
+                    topics: log.topics.map((topic) => bin_fromHexString(topic)),
+                    data: bin_fromHexString(log.data),
+                })),
+            },
+            solanaReceipt: undefined,
+            content: content ?? { case: undefined },
+        });
+        const result = await client.sendEvent(makeUserStreamId(client.userId), make_UserPayload_BlockchainTransaction(transaction), tags);
+        return { txHash: receipt.transactionHash, eventId: result.eventId };
+    };
+    /** Sends a tip to a user.
+     *  Tip will always get funds from the app account balance.
+     * @param params - Tip parameters including recipient, amount, messageId, channelId, currency.
+     * @returns The transaction hash and event ID
+     */
+    const sendTipImpl = async (params, tags) => {
+        const currency = params.currency ?? ETH_ADDRESS;
+        const isEth = currency === ETH_ADDRESS;
+        const { receiver, amount, messageId, channelId } = params;
+        const isGdm = isGDMChannelStreamId(channelId);
+        const accountModulesAddress = client.config.base.chainConfig.addresses.accountModules;
+        if (!isGdm) {
+            throw new Error(`Unsupported stream type for tips: ${channelId}`);
+        }
+        if (!accountModulesAddress) {
+            throw new Error('AccountModules address is not configured for GDM tips');
+        }
+        const recipientType = TipRecipientType.Any;
+        const sender = appAddress; // msg.sender when contract executes
+        const tokenId = undefined;
+        const data = encodeAbiParameters([{ type: 'bytes32' }, { type: 'bytes32' }], [`0x${messageId}`, `0x${channelId}`]);
+        const encodedData = encodeAbiParameters([
+            {
+                type: 'tuple',
+                components: [
+                    { name: 'currency', type: 'address' },
+                    { name: 'sender', type: 'address' },
+                    { name: 'receiver', type: 'address' },
+                    { name: 'amount', type: 'uint256' },
+                    { name: 'data', type: 'bytes' },
+                ],
+            },
+        ], [
+            {
+                currency,
+                sender,
+                receiver,
+                amount,
+                data,
+            },
+        ]);
+        const targetContract = accountModulesAddress;
+        let hash;
+        if (isEth) {
+            hash = await writeContract(viem, {
+                address: targetContract,
+                abi: tippingFacetAbi,
+                functionName: 'sendTip',
+                args: [recipientType, encodedData],
+                value: amount,
+            });
+        }
+        else {
+            const approveHash = await writeContract(viem, {
+                address: currency,
+                abi: erc20Abi,
+                functionName: 'approve',
+                args: [targetContract, amount],
+            });
+            await waitForTransactionReceipt(viem, {
+                hash: approveHash,
+                confirmations: 3,
+            });
+            hash = await writeContract(viem, {
+                address: targetContract,
+                abi: tippingFacetAbi,
+                functionName: 'sendTip',
+                args: [recipientType, encodedData],
+            });
+        }
+        const receipt = await waitForTransactionReceipt(viem, { hash, confirmations: 3 });
+        if (receipt.status !== 'success') {
+            throw new Error(`Tip transaction failed: ${hash}`);
+        }
+        const tipEvent = parseEventLogs({
+            abi: tippingFacetAbi,
+            logs: receipt.logs,
+            eventName: 'TipSent',
+        })[0];
+        return sendBlockchainTransaction(viem.chain.id, receipt, {
+            case: 'tip',
+            value: {
+                event: {
+                    tokenId: tokenId ? BigInt(tokenId) : undefined,
+                    currency: bin_fromHexString(tipEvent.args.currency),
+                    sender: bin_fromHexString(tipEvent.args.sender),
+                    receiver: bin_fromHexString(tipEvent.args.receiver),
+                    amount: tipEvent.args.amount,
+                    messageId: bin_fromHexString(messageId),
+                    channelId: bin_fromHexString(channelId),
+                },
+                toUserAddress: bin_fromHexString(params.receiverUserId),
+            },
+        }, {
+            groupMentionTypes: tags?.groupMentionTypes || [],
+            mentionedUserAddresses: tags?.mentionedUserAddresses || [],
+            threadId: tags?.threadId,
+            appClientAddress: tags?.appClientAddress,
+            messageInteractionType: MessageInteractionType.TIP,
+            participatingUserAddresses: [bin_fromHexString(params.receiverUserId)],
+        });
+    };
+    /** Sends a tip to a user by looking up their smart account by userId.
+     *  Tip will always get funds from the app account balance.
+     * @param params - Tip parameters including userId, amount, messageId, channelId, currency.
+     * @returns The transaction hash and event ID
+     */
+    const sendTip = async (params, tags) => {
+        return sendTipImpl({
+            ...params,
+            receiver: params.userId,
+            receiverUserId: params.userId,
+        }, tags);
+    };
+    const joinUser = async (streamId, userId) => {
+        return client.sendEvent(makeUserStreamId(client.userId), make_UserPayload_UserMembershipAction({
+            op: MembershipOp.SO_JOIN,
+            userId: addressFromUserId(userId),
+            streamId: streamIdAsBytes(streamId),
+        }));
+    };
+    return {
+        sendMessage,
+        editMessage,
+        sendReaction,
+        sendInteractionRequest,
+        sendGM,
+        sendRawGM,
+        sendConversationSeed,
+        removeEvent,
+        sendKeySolicitation,
+        uploadDeviceKeys,
+        pinMessage,
+        unpinMessage,
+        getChannelSettings,
+        sendBlockchainTransaction,
+        sendTip,
+        joinUser,
+    };
+};
+/**
+ * Given a slash command message, returns the command and the arguments
+ * @example
+ * ```
+ * /help
+ * args: []
+ * ```
+ * ```
+ * /sum 1 2
+ * args: ['1', '2']
+ * ```
+ */
+const parseSlashCommand = (message) => {
+    const parts = message.split(' ');
+    const commandWithSlash = parts[0];
+    const command = commandWithSlash.substring(1);
+    const args = parts.slice(1);
+    return { command, args };
+};
+const parseMentions = (mentions) => 
+// Agents doesn't care about @channel or @role mentions
+mentions.flatMap((m) => m.mentionBehavior.case === undefined
+    ? [{ userId: m.userId, displayName: m.displayName }]
+    : []);
+const processMentions = (mentions) => {
+    if (!mentions) {
+        return [];
+    }
+    return mentions.map((mention) => {
+        if ('userId' in mention) {
+            return create(ChannelMessage_Post_MentionSchema, {
+                userId: mention.userId,
+                displayName: mention.displayName,
+            });
+        }
+        else if ('roleId' in mention) {
+            return create(ChannelMessage_Post_MentionSchema, {
+                mentionBehavior: {
+                    case: 'atRole',
+                    value: {
+                        roleId: mention.roleId,
+                    },
+                },
+            });
+        }
+        else if ('atChannel' in mention) {
+            return create(ChannelMessage_Post_MentionSchema, {
+                mentionBehavior: {
+                    case: 'atChannel',
+                    value: create(EmptySchema, {}),
+                },
+            });
+        }
+        else {
+            throw new Error(`Invalid mention type: ${JSON.stringify(mention)}`);
+        }
+    });
+};
+const createBasePayload = (userId, streamId, eventId, createdAt, event, user) => {
+    const isGdm = isGDMChannelStreamId(streamId);
+    const isDm = false;
+    return {
+        userId,
+        channelId: streamId,
+        eventId,
+        createdAt,
+        event,
+        isDm,
+        isGdm,
+        user,
+    };
+};
+//# sourceMappingURL=app.js.map