@towns-labs/agent 2.0.1

package/dist/agent.js

@@ -0,0 +1,1758 @@
+import { create, fromBinary, fromJsonString, toBinary } from '@bufbuild/protobuf';
+import { utils, ethers } from 'ethers';
+import { SpaceDapp, SpaceAddressFromSpaceId, TipRecipientType, ETH_ADDRESS, } from '@towns-labs/web3';
+import { stringify as superjsonStringify, parse as superjsonParse } from 'superjson';
+import tippingFacetAbi from '@towns-labs/generated/dev/abis/ITipping.abi';
+import { getRefEventIdFromChannelMessage, isChannelStreamId, make_ChannelPayload_Message, createTownsClient, streamIdAsString, make_MemberPayload_KeySolicitation, make_UserMetadataPayload_EncryptionDevice, logNever, userIdFromAddress, makeUserMetadataStreamId, unsafe_makeTags, townsEnv, spaceIdFromChannelId, parseAppPrivateData, makeEvent, make_MediaPayload_Inception, make_MediaPayload_Chunk, makeUniqueMediaStreamId, streamIdAsBytes, addressFromUserId, make_payload_InteractionRequest, userIdToAddress, unpackEnvelope, make_UserPayload_BlockchainTransaction, makeUserStreamId, make_MemberPayload_Pin, make_MemberPayload_Unpin, isDMChannelStreamId, isGDMChannelStreamId, make_DMChannelPayload_Message, 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, ChunkedMediaSchema, CreationCookieSchema, BlockchainTransactionSchema, InteractionRequestPayloadSchema, InteractionResponsePayloadSchema, ChannelMessage_Post_AttachmentSchema, ChannelMessage_Post_MentionSchema, } 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 './eventDedup';
+import { isFlattenedRequest, flattenedToPayloadContent, } from './interaction-api';
+import { chainIdToNetwork, createPaymentRequest } from './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';
+import appRegistryAbi from '@towns-labs/generated/dev/abis/IAppRegistry.abi';
+import { getSmartAccountFromUserIdImpl } from './smart-account';
+import { EmptySchema } from '@bufbuild/protobuf/wkt';
+const debug = dlog('csb:agent');
+export class Agent {
+    client;
+    appAddress;
+    agentUserId;
+    viem;
+    jwtSecret;
+    currentMessageTags;
+    emitter = createNanoEvents();
+    slashCommandHandlers = new Map();
+    gmTypedHandlers = new Map();
+    commands;
+    identityConfig;
+    eventDedup;
+    // Payment related members
+    paymentConfig;
+    pendingPayments = new Map();
+    paymentCommands = new Map();
+    constructor(clientV2, viem, jwtSecretBase64, appAddress, commands, identityConfig, dedupConfig, paymentConfig) {
+        this.client = clientV2;
+        this.agentUserId = clientV2.userId;
+        this.viem = viem;
+        this.jwtSecret = bin_fromBase64(jwtSecretBase64);
+        this.currentMessageTags = undefined;
+        this.commands = commands;
+        this.appAddress = appAddress;
+        this.identityConfig = identityConfig;
+        this.eventDedup = new EventDedup(dedupConfig);
+        this.paymentConfig = paymentConfig;
+        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));
+    }
+    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/agent] Error while handling event', err);
+                }
+            }
+            response = statusResponse;
+        }
+        else if (request.payload.case === 'status') {
+            response = statusResponse;
+        }
+        c.header('Content-Type', 'application/x-protobuf');
+        return c.body(toBinary(AppServiceResponseSchema, response), 200);
+    }
+    async handleEvent(appEvent) {
+        if (!appEvent.payload.case || !appEvent.payload.value)
+            return;
+        const streamId = streamIdAsString(appEvent.payload.value.streamId);
+        if (appEvent.payload.case === 'messages') {
+            const groupEncryptionSessionsMessages = 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 [];
+            }));
+            const events = await this.client.unpackEnvelopes(appEvent.payload.value.messages);
+            const zip = events.map((m, i) => [m, groupEncryptionSessionsMessages[i]]);
+            for (const [parsed, groupEncryptionSession] of zip) {
+                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;
+                debug('emit:streamEvent', {
+                    userId: userIdFromAddress(parsed.event.creatorAddress),
+                    channelId: streamId,
+                    eventId: parsed.hashStr,
+                });
+                this.emitter.emit('streamEvent', this.client, {
+                    ...createBasePayload(userIdFromAddress(parsed.event.creatorAddress), streamId, parsed.hashStr, createdAt, parsed.event),
+                    parsed: parsed,
+                });
+                switch (parsed.event.payload.case) {
+                    case 'channelPayload':
+                    case 'dmChannelPayload':
+                    case 'gdmChannelPayload': {
+                        if (!parsed.event.payload.value.content.case)
+                            return;
+                        if (parsed.event.payload.value.content.case === 'message') {
+                            await this.client.importGroupEncryptionSessions({
+                                streamId,
+                                sessions: groupEncryptionSession,
+                            });
+                            const eventCleartext = await this.client.crypto.decryptGroupEvent(streamId, parsed.event.payload.value.content.value);
+                            let channelMessage;
+                            if (typeof eventCleartext === 'string') {
+                                channelMessage = fromJsonString(ChannelMessageSchema, eventCleartext);
+                            }
+                            else {
+                                channelMessage = fromBinary(ChannelMessageSchema, eventCleartext);
+                            }
+                            await this.handleChannelMessage(streamId, parsed, channelMessage);
+                        }
+                        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(userIdFromAddress(parsed.event.creatorAddress), streamId, parsed.hashStr, createdAt, parsed.event),
+                                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(userIdFromAddress(parsed.event.creatorAddress), streamId, parsed.hashStr, createdAt, parsed.event),
+                                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 isChannel = isChannelStreamId(streamId);
+                                    // TODO: do we want agent to listen to onSpaceJoin/onSpaceLeave?
+                                    if (!isChannel)
+                                        continue;
+                                    if (membership.op === MembershipOp.SO_JOIN) {
+                                        debug('emit:channelJoin', {
+                                            userId: userIdFromAddress(membership.userAddress),
+                                            channelId: streamId,
+                                            eventId: parsed.hashStr,
+                                        });
+                                        this.emitter.emit('channelJoin', this.client, {
+                                            ...createBasePayload(userIdFromAddress(membership.userAddress), streamId, parsed.hashStr, createdAt, parsed.event),
+                                        });
+                                    }
+                                    if (membership.op === MembershipOp.SO_LEAVE) {
+                                        debug('emit:channelLeave', {
+                                            userId: userIdFromAddress(membership.userAddress),
+                                            channelId: streamId,
+                                            eventId: parsed.hashStr,
+                                        });
+                                        this.emitter.emit('channelLeave', this.client, {
+                                            ...createBasePayload(userIdFromAddress(membership.userAddress), streamId, parsed.hashStr, createdAt, parsed.event),
+                                        });
+                                    }
+                                }
+                                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),
+                                                });
+                                                this.emitter.emit('tip', this.client, {
+                                                    ...createBasePayload(senderUserId, streamId, parsed.hashStr, createdAt, parsed.event),
+                                                    amount: tipEvent.amount,
+                                                    currency: currency,
+                                                    senderAddress,
+                                                    receiverAddress,
+                                                    receiverUserId,
+                                                    messageId: bin_toHexString(tipEvent.messageId),
+                                                });
+                                            }
+                                            break;
+                                        case undefined:
+                                            break;
+                                        default:
+                                            logNever(transactionContent);
+                                    }
+                                }
+                                break;
+                            case 'keySolicitation':
+                            case 'keyFulfillment':
+                            case 'displayName':
+                            case 'username':
+                            case 'ensAddress':
+                            case 'nft':
+                            case 'pin':
+                            case 'unpin':
+                            case 'encryptionAlgorithm':
+                                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);
+        }
+    }
+    async handleChannelMessage(streamId, parsed, { payload }) {
+        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),
+                        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),
+                        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),
+                                    typeUrl,
+                                    data: result.value,
+                                });
+                            }
+                        }
+                        catch (error) {
+                            debug('GM handler error', { typeUrl, error });
+                        }
+                    }
+                }
+                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),
+                    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),
+                    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),
+                    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;
+    }
+    /**
+     * 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;
+    }
+    // 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);
+        }
+    }
+    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 smartAccountAddress = await getSmartAccountFromUserIdImpl(this.client.config.base.chainConfig.addresses.spaceFactory, this.viem, event.userId);
+                const { signatureId, params, eventId } = await createPaymentRequest(handler, event, chainId, smartAccountAddress, 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;
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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
+     * Fetches metadata from the App Registry and merges with local config
+     * @returns The ERC-8004 compliant metadata object or null
+     */
+    async getIdentityMetadata() {
+        // Fetch metadata from App Registry
+        let appMetadata;
+        try {
+            const appRegistry = await this.client.appServiceClient();
+            const response = await appRegistry.getAppMetadata({
+                appId: bin_fromHexString(this.agentUserId),
+            });
+            appMetadata = response.metadata;
+        }
+        catch (err) {
+            // eslint-disable-next-line no-console
+            console.warn('[@towns-labs/agent] Failed to fetch app metadata', err);
+        }
+        // If no config and no fetched metadata, return null
+        if (!this.identityConfig && !appMetadata)
+            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 || appMetadata?.displayName || 'Unknown Agent';
+        const description = this.identityConfig?.description || appMetadata?.description || '';
+        const image = this.identityConfig?.image || appMetadata?.avatarUrl || appMetadata?.imageUrl || '';
+        const motto = this.identityConfig?.motto || appMetadata?.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) || [],
+            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 makeTownsAgent = async (appPrivateData, jwtSecretBase64, opts = {}) => {
+    const { baseRpcUrl, ...clientOpts } = opts;
+    let appAddress;
+    const { privateKey, encryptionDevice, env, appAddress: appAddressFromPrivateData, } = parseAppPrivateData(appPrivateData);
+    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,
+    });
+    const spaceDapp = new SpaceDapp(baseConfig.chainConfig, new ethers.providers.JsonRpcProvider(baseRpcUrl || baseConfig.rpcUrl));
+    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, spaceDapp, appAddress)));
+    if (opts.commands) {
+        client
+            .appServiceClient()
+            .then((appRegistryClient) => appRegistryClient
+            .updateAppMetadata({
+            appId: bin_fromHexString(account.address),
+            updateMask: ['slash_commands'],
+            metadata: {
+                slashCommands: opts.commands,
+            },
+        })
+            .catch((err) => {
+            // eslint-disable-next-line no-console
+            console.warn('[@towns-labs/agent] failed to update slash commands', err);
+        }))
+            .catch((err) => {
+            // eslint-disable-next-line no-console
+            console.warn('[@towns-labs/agent] failed to get app registry rpc client', err);
+        });
+    }
+    await client.uploadDeviceKeys();
+    return new Agent(client, viem, jwtSecretBase64, appAddress, opts.commands, opts.identity, opts.dedup, opts.paymentConfig);
+};
+const buildAgentActions = (client, viem, spaceDapp, 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 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);
+        let eventPayload;
+        if (isChannelStreamId(streamId)) {
+            eventPayload = make_ChannelPayload_Message(message);
+        }
+        else if (isDMChannelStreamId(streamId)) {
+            eventPayload = make_DMChannelPayload_Message(message);
+        }
+        else if (isGDMChannelStreamId(streamId)) {
+            eventPayload = make_GDMChannelPayload_Message(message);
+        }
+        else {
+            throw new Error(`Invalid stream ID type: ${streamId}`);
+        }
+        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;
+                    }
+                    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;
+                    }
+                    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 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) => {
+        const spaceId = spaceIdFromChannelId(channelId);
+        const streamView = await client.getStream(spaceId);
+        const channel = streamView.spaceContent.spaceChannelsMetadata[channelId];
+        return channel;
+    };
+    // Implementation
+    async function sendInteractionRequest(streamId, contentOrPayload, recipientOrOpts, optsOrTags, maybeTags) {
+        // Detect which format is being used
+        let content;
+        let recipient;
+        let opts;
+        let tags;
+        if (isFlattenedRequest(contentOrPayload)) {
+            // New flattened format
+            content = flattenedToPayloadContent(contentOrPayload);
+            recipient = contentOrPayload.recipient
+                ? bin_fromHexString(contentOrPayload.recipient)
+                : undefined;
+            opts = recipientOrOpts;
+            tags = optsOrTags;
+        }
+        else {
+            // Old format
+            content = contentOrPayload;
+            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);
+        return client.sendEvent(streamId, eventPayload, tags, opts?.ephemeral);
+    }
+    /**
+     * 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 isDm = isDMChannelStreamId(channelId);
+        const isGdm = isGDMChannelStreamId(channelId);
+        const accountModulesAddress = client.config.base.chainConfig.addresses.accountModules;
+        if ((isDm || isGdm) && !accountModulesAddress) {
+            throw new Error('AccountModules address is not configured for DM/GDM tips');
+        }
+        let recipientType;
+        let encodedData;
+        let targetContract;
+        let tokenId;
+        if (isDm || isGdm) {
+            // DM tips use AnyTipParams sent to AccountModules contract
+            recipientType = TipRecipientType.Any;
+            const sender = appAddress; // msg.sender when contract executes
+            const data = encodeAbiParameters([{ type: 'bytes32' }, { type: 'bytes32' }], [`0x${messageId}`, `0x${channelId}`]);
+            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,
+                },
+            ]);
+            targetContract = accountModulesAddress;
+            tokenId = undefined;
+        }
+        else {
+            // Member tips use MembershipTipParams sent to Space contract
+            recipientType = TipRecipientType.Member;
+            const spaceId = spaceIdFromChannelId(channelId);
+            tokenId = await spaceDapp.getTokenIdOfOwner(spaceId, receiver);
+            if (!tokenId) {
+                throw new Error(`No token ID found for user ${receiver} in space ${spaceId}`);
+            }
+            const metadataData = encodeAbiParameters([{ type: 'bytes32' }, { type: 'bytes32' }, { type: 'uint256' }], [`0x${messageId}`, `0x${channelId}`, BigInt(tokenId)]);
+            encodedData = encodeAbiParameters([
+                {
+                    type: 'tuple',
+                    components: [
+                        { name: 'receiver', type: 'address' },
+                        { name: 'tokenId', type: 'uint256' },
+                        { name: 'currency', type: 'address' },
+                        { name: 'amount', type: 'uint256' },
+                        {
+                            name: 'metadata',
+                            type: 'tuple',
+                            components: [
+                                { name: 'messageId', type: 'bytes32' },
+                                { name: 'channelId', type: 'bytes32' },
+                                { name: 'data', type: 'bytes' },
+                            ],
+                        },
+                    ],
+                },
+            ], [
+                {
+                    receiver,
+                    tokenId: BigInt(tokenId),
+                    currency,
+                    amount,
+                    metadata: {
+                        messageId: `0x${messageId}`,
+                        channelId: `0x${channelId}`,
+                        data: metadataData,
+                    },
+                },
+            ]);
+            targetContract = SpaceAddressFromSpaceId(spaceId);
+        }
+        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) => {
+        const smartAccountAddress = await getSmartAccountFromUserIdImpl(client.config.base.chainConfig.addresses.spaceFactory, viem, params.userId);
+        return sendTipImpl({
+            ...params,
+            receiver: smartAccountAddress ?? params.userId,
+            receiverUserId: params.userId,
+        }, tags);
+    };
+    return {
+        sendMessage,
+        editMessage,
+        sendReaction,
+        sendInteractionRequest,
+        sendGM,
+        sendRawGM,
+        removeEvent,
+        sendKeySolicitation,
+        uploadDeviceKeys,
+        pinMessage,
+        unpinMessage,
+        getChannelSettings,
+        sendBlockchainTransaction,
+        sendTip,
+    };
+};
+/**
+ * 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) => {
+    const isDm = isDMChannelStreamId(streamId);
+    const isGdm = isGDMChannelStreamId(streamId);
+    return {
+        userId,
+        channelId: streamId,
+        eventId,
+        createdAt,
+        event,
+        isDm,
+        isGdm,
+    };
+};
+//# sourceMappingURL=agent.js.map