Struct Channel 

pub struct Channel { /* private fields */ }

A unified handle for a chat or channel — a DM and a Community channel behave the same. Every method routes to the right transport under the hood, so a bot author never branches on DM-vs- channel. Obtained from VectorBot::channel / dm / community, or IncomingMessage::channel.

Implementations

impl Channel

pub fn id(&self) -> &str

The id of this chat or channel — an npub for a DM, a channel id for a Community channel.

pub fn kind(&self) -> ChannelKind

Whether this is a DM or a Community channel.

pub fn is_dm(&self) -> bool

true for a direct message.

pub fn is_community(&self) -> bool

true for a Community channel.

pub async fn send(&self, text: &str) -> Result<String>

Send a text message. Returns the new message’s event id.

Examples found in repository

examples/whitelist_bot.rs (line 43)

async fn main() -> vector_sdk::Result<()> {
    let nsec = std::env::var("VECTOR_NSEC").expect("set VECTOR_NSEC to your bot's nsec");
    let whitelist: Vec<String> = std::env::var("VECTOR_WHITELIST")
        .unwrap_or_default()
        .split(',')
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty())
        .collect();

    // Only invites from these npubs are auto-accepted; all others stay parked.
    let bot = VectorBot::builder().nsec(nsec).whitelist(whitelist).build().await?;

    println!("Private bot online as {}", bot.npub());
    for c in bot.communities().await {
        println!("  already a member of community {}", c.id());
    }

    bot.on_event(|bot, event| async move {
        match event {
            // An invite arrived. A whitelisted inviter means it's already being joined;
            // anyone else leaves it parked for you to review via bot.pending_invites().
            BotEvent::Invite { community_id } => {
                println!("invite to {community_id} (auto-join attempted per whitelist)");
            }
            // Best-effort hello once we land in a community we accepted.
            BotEvent::MemberJoin { channel_id, npub } if npub == bot.npub() => {
                let _ = bot.channel(channel_id).send("Hello! Reporting for duty 🫡").await;
            }
            BotEvent::Message(msg) if !msg.is_mine() => {
                let _ = msg.reply("At your service. 🛡️").await;
            }
            _ => {}
        }
    })
    .await?;

    Ok(())
}

examples/moderation_bot.rs (line 35)

async fn main() -> vector_sdk::Result<()> {
    let nsec = std::env::var("VECTOR_NSEC").expect("set VECTOR_NSEC to your bot's nsec");

    // `.public()` lets anyone invite the bot into their community to moderate it.
    let bot = VectorBot::builder().nsec(nsec).public().build().await?;
    println!("Moderation bot online as {}", bot.npub());

    bot.on_event(|bot, event| async move {
        match event {
            // Greet new arrivals in the channel they joined.
            BotEvent::MemberJoin { channel_id, npub } => {
                let who = &npub[..npub.len().min(12)];
                let _ = bot.channel(channel_id).send(&format!("👋 Welcome, {who}!")).await;
            }

            // Screen community messages; ban posters of banned words (never admins or ourselves).
            BotEvent::Message(msg) if msg.is_group && !msg.is_mine() => {
                let lower = msg.text().to_lowercase();
                if !BANNED_WORDS.iter().any(|w| lower.contains(w)) {
                    return;
                }
                if let Some(member) = msg.member() {
                    if member.is_admin() {
                        return; // never moderate admins or the owner
                    }
                    match member.ban().await {
                        Ok(()) => println!("Banned {} for a banned word", member.npub()),
                        Err(e) => eprintln!("Couldn't ban {}: {e}", member.npub()),
                    }
                }
            }

            _ => {}
        }
    })
    .await?;

    Ok(())
}

examples/v2_send_once.rs (line 58)

async fn main() -> vector_sdk::Result<()> {
    let mut args = std::env::args().skip(1);
    let invite = args.next().expect("arg 1: invite link");
    let channel_name = args.next().expect("arg 2: channel name");
    let text = args.next().expect("arg 3: message text");

    let data_dir = std::env::temp_dir().join("v2_send_once_data");
    let bot = VectorBot::builder().data_dir(&data_dir).build().await?;
    println!("── sender online as {}", bot.npub());

    println!("── joining via link…");
    let summary = bot.core().join_community(&invite).await?;
    let name = summary.get("name").and_then(|v| v.as_str()).unwrap_or("?");
    println!("── joined \"{name}\"");

    // The join-time fold is owner-only; admin-created channels arrive on the first
    // control follow. Poll the local list until the target channel appears.
    let mut channel_id: Option<String> = None;
    for attempt in 0..10 {
        for c in bot.core().list_communities().await {
            if c.get("version").and_then(|v| v.as_u64()) != Some(2) {
                continue;
            }
            let Some(chans) = c.get("channels").and_then(|v| v.as_array()) else { continue };
            for ch in chans {
                if ch.get("name").and_then(|n| n.as_str()) == Some(channel_name.as_str()) {
                    channel_id = ch.get("channel_id").and_then(|i| i.as_str()).map(String::from);
                }
            }
        }
        if channel_id.is_some() {
            break;
        }
        if attempt == 0 {
            println!("── \"{channel_name}\" not in the join snapshot; syncing for the control fold…");
        }
        let _ = bot.core().sync_communities().await;
        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
    }
    let Some(channel_id) = channel_id else {
        eprintln!("!! channel \"{channel_name}\" never appeared; giving up");
        std::process::exit(1);
    };
    println!("── channel \"{channel_name}\" = {channel_id}");

    match bot.channel(&channel_id).send(&text).await {
        Ok(id) => println!("── sent ✅  message id {id}"),
        Err(e) => {
            eprintln!("!! send failed: {e}");
            std::process::exit(1);
        }
    }
    // Give the gift-wrap publish + persistence a moment to flush before exit.
    tokio::time::sleep(std::time::Duration::from_secs(5)).await;
    Ok(())
}

examples/v2_typing_probe.rs (line 115)

async fn main() -> vector_sdk::Result<()> {
    let channel_name = std::env::args().nth(1).unwrap_or_else(|| "spam and testing".into());

    let data_dir = std::env::temp_dir().join("v2_send_once_data");
    let bot = VectorBot::builder().data_dir(&data_dir).build().await?;
    println!("── probe online as {}", bot.npub());

    // Find the joined v2 community + the target channel id.
    let (mut community_hex, mut channel_hex) = (None::<String>, None::<String>);
    for c in bot.core().list_communities().await {
        if c.get("version").and_then(|v| v.as_u64()) != Some(2) {
            continue;
        }
        let cid = c.get("community_id").and_then(|v| v.as_str()).map(String::from);
        for ch in c.get("channels").and_then(|v| v.as_array()).cloned().unwrap_or_default() {
            if ch.get("name").and_then(|n| n.as_str()) == Some(channel_name.as_str()) {
                community_hex = cid.clone();
                channel_hex = ch.get("channel_id").and_then(|i| i.as_str()).map(String::from);
            }
        }
    }
    let (community_hex, channel_hex) = match (community_hex, channel_hex) {
        (Some(c), Some(ch)) => (c, ch),
        _ => {
            eprintln!("!! channel \"{channel_name}\" not held locally — join first (run v2_send_once once)");
            std::process::exit(1);
        }
    };

    // Load the community row for relays + root, and derive the channel plane pk
    // exactly as the send/subscribe paths do.
    let cid = vector_core::community::CommunityId(vector_core::simd::hex::hex_to_bytes_32(&community_hex));
    let community = vector_core::db::community::load_community_v2(&cid)
        .map_err(vector_core::VectorError::Other)?
        .ok_or(vector_core::VectorError::Other("community row missing".into()))?;
    let chid = vector_core::community::ChannelId(vector_core::simd::hex::hex_to_bytes_32(&channel_hex));
    let ch = community.channel(&chid).ok_or(vector_core::VectorError::Other("channel missing".into()))?;
    let (secret, epoch) = community.channel_secret(ch);
    let plane_pk = vector_core::community::v2::derive::channel_group_key(&secret, &chid, epoch).pk();
    println!("── channel \"{channel_name}\" plane pk = {plane_pk}");
    println!("── community relays: {:?}", community.relays);

    // One RAW single-relay client per community relay, each with its own live
    // typing subscription — per-relay forwarding becomes directly observable.
    // Every arriving wrap is opened with the plane key and its rumor dumped
    // verbatim: exactly what Armada's `openWrap` + freshness check would see.
    let group = vector_core::community::v2::derive::channel_group_key(&secret, &chid, epoch);
    for relay in community.relays.clone() {
        let plane_pk = plane_pk;
        let group = group.clone();
        tokio::spawn(async move {
            let client = Client::default();
            if client.add_relay(&relay).await.is_err() {
                println!("[{relay}] add failed");
                return;
            }
            client.connect().await;
            let filter = Filter::new().kind(Kind::Custom(21059)).author(plane_pk);
            if let Err(e) = client.subscribe(filter, None).await {
                println!("[{relay}] subscribe failed: {e}");
                return;
            }
            println!("[{relay}] subscribed");
            let mut notifications = client.notifications();
            while let Ok(n) = notifications.recv().await {
                if let RelayPoolNotification::Event { event, .. } = n {
                    println!(
                        "[{relay}] ← 21059 wrap id={} wrap_created_at={} size={}B",
                        &event.id.to_hex()[..12],
                        event.created_at,
                        event.content.len()
                    );
                    match vector_core::community::v2::stream::open_wrap(&event, &group) {
                        Ok(opened) => {
                            let now = std::time::SystemTime::now()
                                .duration_since(std::time::UNIX_EPOCH)
                                .map(|d| d.as_millis() as u64)
                                .unwrap_or(0);
                            let age = now as i128 - opened.at_ms as i128;
                            println!(
                                "    rumor: kind={} author={} created_at={} content={:?}",
                                opened.rumor.kind,
                                &opened.author.to_hex()[..12],
                                opened.rumor.created_at,
                                opened.rumor.content
                            );
                            println!("    tags:  {:?}", opened.rumor.tags.iter().map(|t| t.as_slice().to_vec()).collect::<Vec<_>>());
                            println!("    seal:  kind={} created_at={}", opened.seal.kind, opened.seal.created_at);
                            println!("    at_ms={} (age {age} ms → Armada freshness gate {} 8000ms)", opened.at_ms, if age <= 8000 { "PASSES ≤" } else { "FAILS >" });
                        }
                        Err(e) => println!("    !! open failed: {e}"),
                    }
                }
            }
        });
    }
    tokio::time::sleep(std::time::Duration::from_secs(4)).await;

    // Trigger the resident bot: a normal chat message it answers with ch.typing().
    println!("── sending !typing into \"{channel_name}\"…");
    match bot.channel(&channel_hex).send("!typing").await {
        Ok(_) => println!("── trigger sent; watching 25s for the bot's typing wrap…"),
        Err(e) => eprintln!("!! trigger send failed: {e}"),
    }
    tokio::time::sleep(std::time::Duration::from_secs(25)).await;
    println!("── probe done");
    Ok(())
}

examples/concordia.rs (line 204)

async fn main() -> vector_sdk::Result<()> {
    // Identity: VECTOR_NSEC override, else the persisted <data_dir>/identity.nsec
    // (created on first run by the builder). Public invite policy: any member can
    // pull the bot into their community with a direct invite (v1 or v2).
    let mut builder = VectorBot::builder().public();
    if let Ok(nsec) = std::env::var("VECTOR_NSEC") {
        builder = builder.nsec(nsec);
    }
    let bot = builder.build().await?;
    println!("── {NAME} online as {}", bot.npub());

    // Optional one-shot profile publish: upload the avatar plainly (avatars are
    // public) and publish the kind-0 with the bot flag. Existing fields are
    // carried forward by the profile pipeline, so this never clobbers. Deferred
    // until after listen() has connected the community relays — a kind-0 that
    // only reaches the login relays is invisible to community peers' clients.
    if let Ok(avatar_path) = std::env::var("CONCORDIA_AVATAR") {
        let bot = bot.clone();
        tokio::spawn(async move {
            tokio::time::sleep(std::time::Duration::from_secs(10)).await;
            let avatar_path = shellexpand_home(&avatar_path);
            println!("── uploading avatar {avatar_path}…");
            match bot.core().upload_public_image(&avatar_path).await {
                Ok(url) => {
                    let ok = bot.core().update_bot_profile(NAME, &url, "", ABOUT).await;
                    println!("── profile publish {}  avatar={url}", if ok { "✅" } else { "FAILED" });
                    if ok {
                        push_profile_to_communities().await;
                    }
                }
                Err(e) => eprintln!("!! avatar upload failed: {e}"),
            }
        });
    }

    // Optional invite link: join on first run; later runs come up with the
    // persisted memberships and need no arguments.
    if let Some(invite) = std::env::args().nth(1).or_else(|| std::env::var("VECTOR_INVITE").ok()) {
        println!("── joining via link…");
        match bot.core().join_community(&invite).await {
            Ok(summary) => {
                let name = summary.get("name").and_then(|v| v.as_str()).unwrap_or("?");
                let ver = summary.get("version").and_then(|v| v.as_u64()).unwrap_or(0);
                println!("── joined \"{name}\"  protocol=v{ver}");
            }
            Err(e) => {
                eprintln!("!! join failed: {e}");
                return Err(e);
            }
        }
    }

    // Slash commands (Bot Interface Phase 1): registered here, published as the
    // kind-10304 manifest at listen start, invoked by PLAIN TEXT from any client.
    // Vector's `/` picker renders exactly this registry with argument hints; a
    // matched invocation is consumed before the legacy !bang console below.
    bot.command("help", "List everything Concordia can do").run(|ctx| async move {
        let _ = ctx.reply(HELP).await;
    });
    bot.command("ping", "Round-trip latency check").run(|ctx| async move {
        let _ = ctx.reply(format!("pong 🏓 ({} ms)", now_ms())).await;
    });
    bot.command("roll", "Roll a die")
        .int("sides", "How many sides (default 6)", false)
        .run(|ctx| async move {
            let sides = ctx.int("sides").unwrap_or(6).clamp(2, 1_000_000);
            let roll = (now_ms() as i64 % sides) + 1;
            let _ = ctx.reply(format!("🎲 rolled {roll} on a d{sides}")).await;
        });
    bot.command("announce", "Format a two-part announcement")
        .string("title", "Announcement title", true)
        .string("body", "Announcement body", true)
        .run(|ctx| async move {
            let title = ctx.str("title").unwrap_or("(untitled)").to_string();
            let body = ctx.str("body").unwrap_or_default().to_string();
            let _ = ctx.reply(format!("📣 {title}\n{body}")).await;
        });
    // ── Param-type test battery: every ArgType, solo and mixed ──────────────
    bot.command("typetest", "Echo back every param type, parsed")
        .string("text", "Any free text", true)
        .int("count", "A whole number", true)
        .number("ratio", "A decimal number", true)
        .flag("loud", "true or false", true)
        .user("who", "Any user (npub)", true)
        .choice("color", "Pick a color", ["red", "green", "blue"], true)
        .run(|ctx| async move {
            let report = format!(
                "typetest received:\n\
                 text   (String) = {:?}\n\
                 count  (Int)    = {}\n\
                 ratio  (Number) = {}\n\
                 loud   (Bool)   = {}\n\
                 who    (User)   = {}\n\
                 color  (Choice) = {}",
                ctx.str("text").unwrap_or_default(),
                ctx.int("count").unwrap_or_default(),
                ctx.number("ratio").unwrap_or_default(),
                ctx.flag("loud").unwrap_or_default(),
                ctx.str("who").unwrap_or_default(),
                ctx.str("color").unwrap_or_default(),
            );
            let _ = ctx.reply(report).await;
        });
    bot.command("greet", "Greet a member in a chosen style")
        .user("who", "Who to greet", true)
        .choice("style", "Greeting style", ["formal", "casual", "pirate"], true)
        .int("times", "Repeat 1-5 times (default 1)", false)
        .run(|ctx| async move {
            let who = ctx.str("who").unwrap_or_default().to_string();
            let line = match ctx.str("style").unwrap_or("casual") {
                "formal" => format!("Good day to you, {who}."),
                "pirate" => format!("Ahoy, {who}! 🏴‍☠️"),
                _ => format!("yo {who} 👋"),
            };
            let times = ctx.int("times").unwrap_or(1).clamp(1, 5) as usize;
            let _ = ctx.reply(vec![line; times].join("\n")).await;
        });
    bot.command("calc", "Do some arithmetic")
        .number("a", "First operand", true)
        .choice("op", "Operation", ["add", "sub", "mul", "div"], true)
        .number("b", "Second operand", true)
        .run(|ctx| async move {
            let a = ctx.number("a").unwrap_or_default();
            let b = ctx.number("b").unwrap_or_default();
            let answer = match ctx.str("op").unwrap_or_default() {
                "add" => Some(a + b),
                "sub" => Some(a - b),
                "mul" => Some(a * b),
                "div" if b != 0.0 => Some(a / b),
                _ => None,
            };
            let _ = ctx
                .reply(match answer {
                    Some(v) => format!("🧮 {v}"),
                    None => "cannot divide by zero".to_string(),
                })
                .await;
        });

    bot.command("reply", "Get a threaded reply to your message").run(|ctx| async move {
        let _ = ctx.reply("this is a threaded reply ✅ (I quoted your message)").await;
    });
    bot.command("react", "React to your message")
        .choice("emoji", "Which reaction", ["🔥", "👍", "❤️", "😂", "🫡"], false)
        .run(|ctx| async move {
            let emoji = ctx.str("emoji").unwrap_or("🔥").to_string();
            log_err("react", ctx.msg.react(&emoji).await.map(|_| String::new()));
        });
    bot.command("edit", "Watch me send then edit a message").run(|ctx| async move {
        let ch = ctx.msg.channel();
        if let Ok(id) = ch.send("editing this in one second…").await {
            log_err("edit", ch.edit(&id, "edited ✏️ (this text was changed)").await.map(|_| String::new()));
        }
    });
    bot.command("delete", "Watch a message self-destruct").run(|ctx| async move {
        let ch = ctx.msg.channel();
        if let Ok(id) = ch.send("…this message will self-destruct").await {
            log_err("delete", ch.delete(&id).await.map(|_| String::new()));
        }
    });
    bot.command("typing", "Emit a typing indicator").run(|ctx| async move {
        log_err("typing", ctx.msg.channel().typing().await.map(|_| String::new()));
    });
    bot.command("file", "Receive a small encrypted attachment").run(|ctx| async move {
        send_test_file(&ctx.msg.channel()).await;
    });
    bot.command("members", "The folded member list").run(|ctx| async move {
        if let Some(community) = ctx.msg.community() {
            let members = community.members().await;
            let list: Vec<String> = members.iter().map(|m| short(m.npub())).collect();
            let _ = ctx.reply(format!("{} member(s): {}", members.len(), list.join(", "))).await;
        } else {
            let _ = ctx.reply("not in a community here").await;
        }
    });
    bot.command("channels", "The channels I can see here").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!channels").await;
    });
    bot.command("caps", "My capabilities here (roles engine)").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!caps").await;
    });
    bot.command("roles", "The community roster").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!roles").await;
    });
    bot.command("info", "Community protocol + ownership summary").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!info").await;
    });
    bot.command("whoami", "My npub and this channel id").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!whoami").await;
    });
    bot.command("reconnect", "Bounce my relay sockets (reconnect drill)").run(|ctx| async move {
        let bounced = bounce_community_relays().await;
        let _ = ctx.reply(format!("bounced {bounced} relay socket(s) — /ping to test the post-reconnect subscription")).await;
    });

    // The join snapshot folds only owner-authored channels; admin-created ones
    // arrive on the first control follow, so re-print once that has landed.
    print_channels(&bot, "channels visible (startup)").await;
    {
        let bot = bot.clone();
        tokio::spawn(async move {
            tokio::time::sleep(std::time::Duration::from_secs(25)).await;
            print_channels(&bot, "channels visible (after control follow)").await;
        });
    }
    println!("── listening. Message me `!help` from your client.\n");

    bot.on_event(|bot, event| async move {
        match event {
            BotEvent::Message(msg) => {
                if msg.is_mine() {
                    return; // never react to our own sends
                }
                let author = short(msg.message.npub.as_deref().unwrap_or("?"));
                let text = msg.text().trim().to_string();
                println!("[MSG]    {author}: {text}");

                // Command console — each arm fires a distinct SDK send-path.
                let ch = msg.channel();
                match text.as_str() {
                    "!help" => reply(&msg, HELP).await,
                    "!ping" => reply(&msg, &format!("pong 🏓 ({} ms)", now_ms())).await,
                    "!reply" => reply(&msg, "this is a threaded reply ✅ (I quoted your message)").await,
                    "!react" => log_err("react", msg.react("🔥").await.map(|_| String::new())),
                    "!typing" => log_err("typing", ch.typing().await.map(|_| String::new())),
                    "!edit" => {
                        if let Ok(id) = ch.send("editing this in one second…").await {
                            log_err("edit", ch.edit(&id, "edited ✏️ (this text was changed)").await.map(|_| String::new()));
                        }
                    }
                    "!delete" => {
                        if let Ok(id) = ch.send("…this message will self-destruct").await {
                            log_err("delete", ch.delete(&id).await.map(|_| String::new()));
                        }
                    }
                    "!file" => send_test_file(&ch).await,
                    "!members" => {
                        if let Some(community) = msg.community() {
                            let members = community.members().await;
                            let list: Vec<String> = members.iter().map(|m| short(m.npub())).collect();
                            reply(&msg, &format!("{} member(s): {}", members.len(), list.join(", "))).await;
                        } else {
                            reply(&msg, "not in a community here").await;
                        }
                    }
                    "!reconnect" => {
                        // Ops/repro tool: bounce this bot's community relay sockets (a
                        // relay restart or idle drop in miniature) — then a !ping proves
                        // whether the subscription survived the fresh AUTH gate.
                        let bounced = bounce_community_relays().await;
                        reply(&msg, &format!("bounced {bounced} relay socket(s) — send !ping to test the post-reconnect subscription")).await;
                    }
                    "!channels" | "!info" | "!caps" | "!roles" | "!whoami" => diagnostics(&bot, &msg, &text).await,
                    other if other.starts_with('!') => reply(&msg, &format!("unknown command `{other}` — try !help")).await,
                    // Non-command chatter is logged above but never replied to, so
                    // the bot can sit in a busy community without spamming echoes.
                    _ => {}
                }
            }
            BotEvent::MessageUpdate { message, .. } => {
                println!("[UPDATE] {} → \"{}\"  ({} reaction(s))", short(message.npub.as_deref().unwrap_or("?")), message.content, message.reactions.len());
            }
            BotEvent::Delete { message_id, .. } => println!("[DELETE] message {}", short(&message_id)),
            BotEvent::MemberJoin { npub, .. } => println!("[JOIN]   {}", short(&npub)),
            BotEvent::MemberLeave { npub, .. } => println!("[LEAVE]  {}", short(&npub)),
            BotEvent::Typing { npub, .. } => println!("[TYPING] {}", short(&npub)),
            BotEvent::Invite { community_id } => println!("[INVITE] for community {}", short(&community_id)),
            BotEvent::Removed { community_id } => println!("[REMOVED] from community {} — I was kicked/banned", short(&community_id)),
        }
    })
    .await?;

    Ok(())
}

pub async fn reply(&self, replied_to: &str, text: &str) -> Result<String>

Send a text message as a threaded reply to replied_to (an existing message’s id). Works for DMs and Community channels. Returns the new message’s event id.

pub async fn react(&self, message_id: &str, emoji: &str) -> Result<()>

React to a message with a unicode emoji (e.g. "👍").

pub async fn react_custom( &self, message_id: &str, shortcode_emoji: &str, image_url: &str, ) -> Result<()>

React with a custom NIP-30 pack emoji: a :shortcode: plus its image URL.

pub async fn typing(&self) -> Result<()>

Send an ephemeral typing indicator. Useful while the bot is “thinking”.

Examples found in repository

examples/echo_bot.rs (line 23)

async fn main() -> vector_sdk::Result<()> {
    let nsec = std::env::var("VECTOR_NSEC").expect("set VECTOR_NSEC to your bot's nsec");

    let bot = VectorBot::builder().nsec(nsec).build().await?;
    println!("Echo bot online as {}", bot.npub());

    // Blocks, processing inbound messages until the client disconnects. The SAME handler and
    // reply work for DMs and Community channels — the SDK hides the transport difference.
    bot.on_message(|_bot, msg| async move {
        if msg.is_mine() {
            return; // don't echo our own messages
        }
        let _ = msg.channel().typing().await;
        let _ = msg.reply(&format!("Echo: {}", msg.text())).await;
    })
    .await?;

    Ok(())
}

examples/v2_community_bot.rs (line 49)

async fn main() -> vector_sdk::Result<()> {
    let nsec = std::env::var("VECTOR_NSEC").expect("set VECTOR_NSEC to your bot's nsec");

    let bot = VectorBot::builder().nsec(nsec).build().await?;
    println!("v2 community bot online as {}", bot.npub());

    // Create-and-invite is opt-in so a restart doesn't spawn a fresh community
    // each time (a real bot persists its community id and reuses it).
    if std::env::var("VECTOR_CREATE").is_ok() {
        // Creation is one hop through the core facade (the ergonomic surface stays at
        // the stable published API). A fresh community is created on the modern protocol.
        let summary = bot.core().create_community_v2("Vector v2 Demo").await?;
        let id = summary.get("community_id").and_then(|v| v.as_str()).unwrap_or_default().to_string();
        let community = bot.community(id);
        println!("created v2 community {}", community.id());

        let url = community.create_invite().await?;
        println!("shareable invite link: {url}");

        if let Ok(guest) = std::env::var("VECTOR_INVITE_NPUB") {
            community.invite(&guest).await?;
            println!("direct-invited {guest}");
        }
    }

    // One handler serves DMs and every Community channel — the SDK hides the
    // transport (and the protocol) difference.
    bot.on_message(|_bot, msg| async move {
        if msg.is_mine() {
            return; // never reply to our own messages (no echo loop)
        }
        let _ = msg.channel().typing().await;
        let _ = msg.reply(&format!("v2 heard: {}", msg.text())).await;
    })
    .await?;

    Ok(())
}

examples/ai_bot.rs (line 47)

async fn main() -> vector_sdk::Result<()> {
    let nsec = std::env::var("VECTOR_NSEC").expect("set VECTOR_NSEC to your bot's nsec");
    std::env::var("OPENAI_API_KEY").expect("set OPENAI_API_KEY for the LLM endpoint");

    let bot = VectorBot::builder().nsec(nsec).build().await?;
    println!("AI bot online as {}", bot.npub());

    // Per-conversation rolling history, shared across handler invocations.
    let history: Arc<Mutex<HashMap<String, Vec<Value>>>> = Arc::new(Mutex::new(HashMap::new()));

    bot.on_message(move |_bot, msg| {
        let history = history.clone();
        async move {
            if msg.is_mine() || msg.text().trim().is_empty() {
                return;
            }

            // Let the user see we're working while the model generates.
            let _ = msg.channel().typing().await;

            // Prompt = system + recent history for this conversation + the new turn.
            let key = msg.chat_id.clone();
            let mut messages = vec![json!({ "role": "system", "content": SYSTEM_PROMPT })];
            if let Some(prior) = history.lock().unwrap().get(&key) {
                messages.extend(prior.iter().cloned());
            }
            messages.push(json!({ "role": "user", "content": msg.text() }));

            match ask_llm(&messages).await {
                Ok(answer) => {
                    let _ = msg.reply(&answer).await;
                    // Remember both sides, trimmed to the last HISTORY_LIMIT messages.
                    let mut store = history.lock().unwrap();
                    let convo = store.entry(key).or_default();
                    convo.push(json!({ "role": "user", "content": msg.text() }));
                    convo.push(json!({ "role": "assistant", "content": answer }));
                    let overflow = convo.len().saturating_sub(HISTORY_LIMIT);
                    convo.drain(0..overflow);
                }
                Err(e) => {
                    let _ = msg.reply(&format!("(LLM error: {e})")).await;
                }
            }
        }
    })
    .await?;

    Ok(())
}

examples/concordia.rs (line 215)

async fn main() -> vector_sdk::Result<()> {
    // Identity: VECTOR_NSEC override, else the persisted <data_dir>/identity.nsec
    // (created on first run by the builder). Public invite policy: any member can
    // pull the bot into their community with a direct invite (v1 or v2).
    let mut builder = VectorBot::builder().public();
    if let Ok(nsec) = std::env::var("VECTOR_NSEC") {
        builder = builder.nsec(nsec);
    }
    let bot = builder.build().await?;
    println!("── {NAME} online as {}", bot.npub());

    // Optional one-shot profile publish: upload the avatar plainly (avatars are
    // public) and publish the kind-0 with the bot flag. Existing fields are
    // carried forward by the profile pipeline, so this never clobbers. Deferred
    // until after listen() has connected the community relays — a kind-0 that
    // only reaches the login relays is invisible to community peers' clients.
    if let Ok(avatar_path) = std::env::var("CONCORDIA_AVATAR") {
        let bot = bot.clone();
        tokio::spawn(async move {
            tokio::time::sleep(std::time::Duration::from_secs(10)).await;
            let avatar_path = shellexpand_home(&avatar_path);
            println!("── uploading avatar {avatar_path}…");
            match bot.core().upload_public_image(&avatar_path).await {
                Ok(url) => {
                    let ok = bot.core().update_bot_profile(NAME, &url, "", ABOUT).await;
                    println!("── profile publish {}  avatar={url}", if ok { "✅" } else { "FAILED" });
                    if ok {
                        push_profile_to_communities().await;
                    }
                }
                Err(e) => eprintln!("!! avatar upload failed: {e}"),
            }
        });
    }

    // Optional invite link: join on first run; later runs come up with the
    // persisted memberships and need no arguments.
    if let Some(invite) = std::env::args().nth(1).or_else(|| std::env::var("VECTOR_INVITE").ok()) {
        println!("── joining via link…");
        match bot.core().join_community(&invite).await {
            Ok(summary) => {
                let name = summary.get("name").and_then(|v| v.as_str()).unwrap_or("?");
                let ver = summary.get("version").and_then(|v| v.as_u64()).unwrap_or(0);
                println!("── joined \"{name}\"  protocol=v{ver}");
            }
            Err(e) => {
                eprintln!("!! join failed: {e}");
                return Err(e);
            }
        }
    }

    // Slash commands (Bot Interface Phase 1): registered here, published as the
    // kind-10304 manifest at listen start, invoked by PLAIN TEXT from any client.
    // Vector's `/` picker renders exactly this registry with argument hints; a
    // matched invocation is consumed before the legacy !bang console below.
    bot.command("help", "List everything Concordia can do").run(|ctx| async move {
        let _ = ctx.reply(HELP).await;
    });
    bot.command("ping", "Round-trip latency check").run(|ctx| async move {
        let _ = ctx.reply(format!("pong 🏓 ({} ms)", now_ms())).await;
    });
    bot.command("roll", "Roll a die")
        .int("sides", "How many sides (default 6)", false)
        .run(|ctx| async move {
            let sides = ctx.int("sides").unwrap_or(6).clamp(2, 1_000_000);
            let roll = (now_ms() as i64 % sides) + 1;
            let _ = ctx.reply(format!("🎲 rolled {roll} on a d{sides}")).await;
        });
    bot.command("announce", "Format a two-part announcement")
        .string("title", "Announcement title", true)
        .string("body", "Announcement body", true)
        .run(|ctx| async move {
            let title = ctx.str("title").unwrap_or("(untitled)").to_string();
            let body = ctx.str("body").unwrap_or_default().to_string();
            let _ = ctx.reply(format!("📣 {title}\n{body}")).await;
        });
    // ── Param-type test battery: every ArgType, solo and mixed ──────────────
    bot.command("typetest", "Echo back every param type, parsed")
        .string("text", "Any free text", true)
        .int("count", "A whole number", true)
        .number("ratio", "A decimal number", true)
        .flag("loud", "true or false", true)
        .user("who", "Any user (npub)", true)
        .choice("color", "Pick a color", ["red", "green", "blue"], true)
        .run(|ctx| async move {
            let report = format!(
                "typetest received:\n\
                 text   (String) = {:?}\n\
                 count  (Int)    = {}\n\
                 ratio  (Number) = {}\n\
                 loud   (Bool)   = {}\n\
                 who    (User)   = {}\n\
                 color  (Choice) = {}",
                ctx.str("text").unwrap_or_default(),
                ctx.int("count").unwrap_or_default(),
                ctx.number("ratio").unwrap_or_default(),
                ctx.flag("loud").unwrap_or_default(),
                ctx.str("who").unwrap_or_default(),
                ctx.str("color").unwrap_or_default(),
            );
            let _ = ctx.reply(report).await;
        });
    bot.command("greet", "Greet a member in a chosen style")
        .user("who", "Who to greet", true)
        .choice("style", "Greeting style", ["formal", "casual", "pirate"], true)
        .int("times", "Repeat 1-5 times (default 1)", false)
        .run(|ctx| async move {
            let who = ctx.str("who").unwrap_or_default().to_string();
            let line = match ctx.str("style").unwrap_or("casual") {
                "formal" => format!("Good day to you, {who}."),
                "pirate" => format!("Ahoy, {who}! 🏴‍☠️"),
                _ => format!("yo {who} 👋"),
            };
            let times = ctx.int("times").unwrap_or(1).clamp(1, 5) as usize;
            let _ = ctx.reply(vec![line; times].join("\n")).await;
        });
    bot.command("calc", "Do some arithmetic")
        .number("a", "First operand", true)
        .choice("op", "Operation", ["add", "sub", "mul", "div"], true)
        .number("b", "Second operand", true)
        .run(|ctx| async move {
            let a = ctx.number("a").unwrap_or_default();
            let b = ctx.number("b").unwrap_or_default();
            let answer = match ctx.str("op").unwrap_or_default() {
                "add" => Some(a + b),
                "sub" => Some(a - b),
                "mul" => Some(a * b),
                "div" if b != 0.0 => Some(a / b),
                _ => None,
            };
            let _ = ctx
                .reply(match answer {
                    Some(v) => format!("🧮 {v}"),
                    None => "cannot divide by zero".to_string(),
                })
                .await;
        });

    bot.command("reply", "Get a threaded reply to your message").run(|ctx| async move {
        let _ = ctx.reply("this is a threaded reply ✅ (I quoted your message)").await;
    });
    bot.command("react", "React to your message")
        .choice("emoji", "Which reaction", ["🔥", "👍", "❤️", "😂", "🫡"], false)
        .run(|ctx| async move {
            let emoji = ctx.str("emoji").unwrap_or("🔥").to_string();
            log_err("react", ctx.msg.react(&emoji).await.map(|_| String::new()));
        });
    bot.command("edit", "Watch me send then edit a message").run(|ctx| async move {
        let ch = ctx.msg.channel();
        if let Ok(id) = ch.send("editing this in one second…").await {
            log_err("edit", ch.edit(&id, "edited ✏️ (this text was changed)").await.map(|_| String::new()));
        }
    });
    bot.command("delete", "Watch a message self-destruct").run(|ctx| async move {
        let ch = ctx.msg.channel();
        if let Ok(id) = ch.send("…this message will self-destruct").await {
            log_err("delete", ch.delete(&id).await.map(|_| String::new()));
        }
    });
    bot.command("typing", "Emit a typing indicator").run(|ctx| async move {
        log_err("typing", ctx.msg.channel().typing().await.map(|_| String::new()));
    });
    bot.command("file", "Receive a small encrypted attachment").run(|ctx| async move {
        send_test_file(&ctx.msg.channel()).await;
    });
    bot.command("members", "The folded member list").run(|ctx| async move {
        if let Some(community) = ctx.msg.community() {
            let members = community.members().await;
            let list: Vec<String> = members.iter().map(|m| short(m.npub())).collect();
            let _ = ctx.reply(format!("{} member(s): {}", members.len(), list.join(", "))).await;
        } else {
            let _ = ctx.reply("not in a community here").await;
        }
    });
    bot.command("channels", "The channels I can see here").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!channels").await;
    });
    bot.command("caps", "My capabilities here (roles engine)").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!caps").await;
    });
    bot.command("roles", "The community roster").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!roles").await;
    });
    bot.command("info", "Community protocol + ownership summary").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!info").await;
    });
    bot.command("whoami", "My npub and this channel id").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!whoami").await;
    });
    bot.command("reconnect", "Bounce my relay sockets (reconnect drill)").run(|ctx| async move {
        let bounced = bounce_community_relays().await;
        let _ = ctx.reply(format!("bounced {bounced} relay socket(s) — /ping to test the post-reconnect subscription")).await;
    });

    // The join snapshot folds only owner-authored channels; admin-created ones
    // arrive on the first control follow, so re-print once that has landed.
    print_channels(&bot, "channels visible (startup)").await;
    {
        let bot = bot.clone();
        tokio::spawn(async move {
            tokio::time::sleep(std::time::Duration::from_secs(25)).await;
            print_channels(&bot, "channels visible (after control follow)").await;
        });
    }
    println!("── listening. Message me `!help` from your client.\n");

    bot.on_event(|bot, event| async move {
        match event {
            BotEvent::Message(msg) => {
                if msg.is_mine() {
                    return; // never react to our own sends
                }
                let author = short(msg.message.npub.as_deref().unwrap_or("?"));
                let text = msg.text().trim().to_string();
                println!("[MSG]    {author}: {text}");

                // Command console — each arm fires a distinct SDK send-path.
                let ch = msg.channel();
                match text.as_str() {
                    "!help" => reply(&msg, HELP).await,
                    "!ping" => reply(&msg, &format!("pong 🏓 ({} ms)", now_ms())).await,
                    "!reply" => reply(&msg, "this is a threaded reply ✅ (I quoted your message)").await,
                    "!react" => log_err("react", msg.react("🔥").await.map(|_| String::new())),
                    "!typing" => log_err("typing", ch.typing().await.map(|_| String::new())),
                    "!edit" => {
                        if let Ok(id) = ch.send("editing this in one second…").await {
                            log_err("edit", ch.edit(&id, "edited ✏️ (this text was changed)").await.map(|_| String::new()));
                        }
                    }
                    "!delete" => {
                        if let Ok(id) = ch.send("…this message will self-destruct").await {
                            log_err("delete", ch.delete(&id).await.map(|_| String::new()));
                        }
                    }
                    "!file" => send_test_file(&ch).await,
                    "!members" => {
                        if let Some(community) = msg.community() {
                            let members = community.members().await;
                            let list: Vec<String> = members.iter().map(|m| short(m.npub())).collect();
                            reply(&msg, &format!("{} member(s): {}", members.len(), list.join(", "))).await;
                        } else {
                            reply(&msg, "not in a community here").await;
                        }
                    }
                    "!reconnect" => {
                        // Ops/repro tool: bounce this bot's community relay sockets (a
                        // relay restart or idle drop in miniature) — then a !ping proves
                        // whether the subscription survived the fresh AUTH gate.
                        let bounced = bounce_community_relays().await;
                        reply(&msg, &format!("bounced {bounced} relay socket(s) — send !ping to test the post-reconnect subscription")).await;
                    }
                    "!channels" | "!info" | "!caps" | "!roles" | "!whoami" => diagnostics(&bot, &msg, &text).await,
                    other if other.starts_with('!') => reply(&msg, &format!("unknown command `{other}` — try !help")).await,
                    // Non-command chatter is logged above but never replied to, so
                    // the bot can sit in a busy community without spamming echoes.
                    _ => {}
                }
            }
            BotEvent::MessageUpdate { message, .. } => {
                println!("[UPDATE] {} → \"{}\"  ({} reaction(s))", short(message.npub.as_deref().unwrap_or("?")), message.content, message.reactions.len());
            }
            BotEvent::Delete { message_id, .. } => println!("[DELETE] message {}", short(&message_id)),
            BotEvent::MemberJoin { npub, .. } => println!("[JOIN]   {}", short(&npub)),
            BotEvent::MemberLeave { npub, .. } => println!("[LEAVE]  {}", short(&npub)),
            BotEvent::Typing { npub, .. } => println!("[TYPING] {}", short(&npub)),
            BotEvent::Invite { community_id } => println!("[INVITE] for community {}", short(&community_id)),
            BotEvent::Removed { community_id } => println!("[REMOVED] from community {} — I was kicked/banned", short(&community_id)),
        }
    })
    .await?;

    Ok(())
}

pub async fn edit(&self, message_id: &str, new_content: &str) -> Result<()>

Edit a message you previously sent.

Examples found in repository

examples/concordia.rs (line 205)

async fn main() -> vector_sdk::Result<()> {
    // Identity: VECTOR_NSEC override, else the persisted <data_dir>/identity.nsec
    // (created on first run by the builder). Public invite policy: any member can
    // pull the bot into their community with a direct invite (v1 or v2).
    let mut builder = VectorBot::builder().public();
    if let Ok(nsec) = std::env::var("VECTOR_NSEC") {
        builder = builder.nsec(nsec);
    }
    let bot = builder.build().await?;
    println!("── {NAME} online as {}", bot.npub());

    // Optional one-shot profile publish: upload the avatar plainly (avatars are
    // public) and publish the kind-0 with the bot flag. Existing fields are
    // carried forward by the profile pipeline, so this never clobbers. Deferred
    // until after listen() has connected the community relays — a kind-0 that
    // only reaches the login relays is invisible to community peers' clients.
    if let Ok(avatar_path) = std::env::var("CONCORDIA_AVATAR") {
        let bot = bot.clone();
        tokio::spawn(async move {
            tokio::time::sleep(std::time::Duration::from_secs(10)).await;
            let avatar_path = shellexpand_home(&avatar_path);
            println!("── uploading avatar {avatar_path}…");
            match bot.core().upload_public_image(&avatar_path).await {
                Ok(url) => {
                    let ok = bot.core().update_bot_profile(NAME, &url, "", ABOUT).await;
                    println!("── profile publish {}  avatar={url}", if ok { "✅" } else { "FAILED" });
                    if ok {
                        push_profile_to_communities().await;
                    }
                }
                Err(e) => eprintln!("!! avatar upload failed: {e}"),
            }
        });
    }

    // Optional invite link: join on first run; later runs come up with the
    // persisted memberships and need no arguments.
    if let Some(invite) = std::env::args().nth(1).or_else(|| std::env::var("VECTOR_INVITE").ok()) {
        println!("── joining via link…");
        match bot.core().join_community(&invite).await {
            Ok(summary) => {
                let name = summary.get("name").and_then(|v| v.as_str()).unwrap_or("?");
                let ver = summary.get("version").and_then(|v| v.as_u64()).unwrap_or(0);
                println!("── joined \"{name}\"  protocol=v{ver}");
            }
            Err(e) => {
                eprintln!("!! join failed: {e}");
                return Err(e);
            }
        }
    }

    // Slash commands (Bot Interface Phase 1): registered here, published as the
    // kind-10304 manifest at listen start, invoked by PLAIN TEXT from any client.
    // Vector's `/` picker renders exactly this registry with argument hints; a
    // matched invocation is consumed before the legacy !bang console below.
    bot.command("help", "List everything Concordia can do").run(|ctx| async move {
        let _ = ctx.reply(HELP).await;
    });
    bot.command("ping", "Round-trip latency check").run(|ctx| async move {
        let _ = ctx.reply(format!("pong 🏓 ({} ms)", now_ms())).await;
    });
    bot.command("roll", "Roll a die")
        .int("sides", "How many sides (default 6)", false)
        .run(|ctx| async move {
            let sides = ctx.int("sides").unwrap_or(6).clamp(2, 1_000_000);
            let roll = (now_ms() as i64 % sides) + 1;
            let _ = ctx.reply(format!("🎲 rolled {roll} on a d{sides}")).await;
        });
    bot.command("announce", "Format a two-part announcement")
        .string("title", "Announcement title", true)
        .string("body", "Announcement body", true)
        .run(|ctx| async move {
            let title = ctx.str("title").unwrap_or("(untitled)").to_string();
            let body = ctx.str("body").unwrap_or_default().to_string();
            let _ = ctx.reply(format!("📣 {title}\n{body}")).await;
        });
    // ── Param-type test battery: every ArgType, solo and mixed ──────────────
    bot.command("typetest", "Echo back every param type, parsed")
        .string("text", "Any free text", true)
        .int("count", "A whole number", true)
        .number("ratio", "A decimal number", true)
        .flag("loud", "true or false", true)
        .user("who", "Any user (npub)", true)
        .choice("color", "Pick a color", ["red", "green", "blue"], true)
        .run(|ctx| async move {
            let report = format!(
                "typetest received:\n\
                 text   (String) = {:?}\n\
                 count  (Int)    = {}\n\
                 ratio  (Number) = {}\n\
                 loud   (Bool)   = {}\n\
                 who    (User)   = {}\n\
                 color  (Choice) = {}",
                ctx.str("text").unwrap_or_default(),
                ctx.int("count").unwrap_or_default(),
                ctx.number("ratio").unwrap_or_default(),
                ctx.flag("loud").unwrap_or_default(),
                ctx.str("who").unwrap_or_default(),
                ctx.str("color").unwrap_or_default(),
            );
            let _ = ctx.reply(report).await;
        });
    bot.command("greet", "Greet a member in a chosen style")
        .user("who", "Who to greet", true)
        .choice("style", "Greeting style", ["formal", "casual", "pirate"], true)
        .int("times", "Repeat 1-5 times (default 1)", false)
        .run(|ctx| async move {
            let who = ctx.str("who").unwrap_or_default().to_string();
            let line = match ctx.str("style").unwrap_or("casual") {
                "formal" => format!("Good day to you, {who}."),
                "pirate" => format!("Ahoy, {who}! 🏴‍☠️"),
                _ => format!("yo {who} 👋"),
            };
            let times = ctx.int("times").unwrap_or(1).clamp(1, 5) as usize;
            let _ = ctx.reply(vec![line; times].join("\n")).await;
        });
    bot.command("calc", "Do some arithmetic")
        .number("a", "First operand", true)
        .choice("op", "Operation", ["add", "sub", "mul", "div"], true)
        .number("b", "Second operand", true)
        .run(|ctx| async move {
            let a = ctx.number("a").unwrap_or_default();
            let b = ctx.number("b").unwrap_or_default();
            let answer = match ctx.str("op").unwrap_or_default() {
                "add" => Some(a + b),
                "sub" => Some(a - b),
                "mul" => Some(a * b),
                "div" if b != 0.0 => Some(a / b),
                _ => None,
            };
            let _ = ctx
                .reply(match answer {
                    Some(v) => format!("🧮 {v}"),
                    None => "cannot divide by zero".to_string(),
                })
                .await;
        });

    bot.command("reply", "Get a threaded reply to your message").run(|ctx| async move {
        let _ = ctx.reply("this is a threaded reply ✅ (I quoted your message)").await;
    });
    bot.command("react", "React to your message")
        .choice("emoji", "Which reaction", ["🔥", "👍", "❤️", "😂", "🫡"], false)
        .run(|ctx| async move {
            let emoji = ctx.str("emoji").unwrap_or("🔥").to_string();
            log_err("react", ctx.msg.react(&emoji).await.map(|_| String::new()));
        });
    bot.command("edit", "Watch me send then edit a message").run(|ctx| async move {
        let ch = ctx.msg.channel();
        if let Ok(id) = ch.send("editing this in one second…").await {
            log_err("edit", ch.edit(&id, "edited ✏️ (this text was changed)").await.map(|_| String::new()));
        }
    });
    bot.command("delete", "Watch a message self-destruct").run(|ctx| async move {
        let ch = ctx.msg.channel();
        if let Ok(id) = ch.send("…this message will self-destruct").await {
            log_err("delete", ch.delete(&id).await.map(|_| String::new()));
        }
    });
    bot.command("typing", "Emit a typing indicator").run(|ctx| async move {
        log_err("typing", ctx.msg.channel().typing().await.map(|_| String::new()));
    });
    bot.command("file", "Receive a small encrypted attachment").run(|ctx| async move {
        send_test_file(&ctx.msg.channel()).await;
    });
    bot.command("members", "The folded member list").run(|ctx| async move {
        if let Some(community) = ctx.msg.community() {
            let members = community.members().await;
            let list: Vec<String> = members.iter().map(|m| short(m.npub())).collect();
            let _ = ctx.reply(format!("{} member(s): {}", members.len(), list.join(", "))).await;
        } else {
            let _ = ctx.reply("not in a community here").await;
        }
    });
    bot.command("channels", "The channels I can see here").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!channels").await;
    });
    bot.command("caps", "My capabilities here (roles engine)").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!caps").await;
    });
    bot.command("roles", "The community roster").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!roles").await;
    });
    bot.command("info", "Community protocol + ownership summary").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!info").await;
    });
    bot.command("whoami", "My npub and this channel id").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!whoami").await;
    });
    bot.command("reconnect", "Bounce my relay sockets (reconnect drill)").run(|ctx| async move {
        let bounced = bounce_community_relays().await;
        let _ = ctx.reply(format!("bounced {bounced} relay socket(s) — /ping to test the post-reconnect subscription")).await;
    });

    // The join snapshot folds only owner-authored channels; admin-created ones
    // arrive on the first control follow, so re-print once that has landed.
    print_channels(&bot, "channels visible (startup)").await;
    {
        let bot = bot.clone();
        tokio::spawn(async move {
            tokio::time::sleep(std::time::Duration::from_secs(25)).await;
            print_channels(&bot, "channels visible (after control follow)").await;
        });
    }
    println!("── listening. Message me `!help` from your client.\n");

    bot.on_event(|bot, event| async move {
        match event {
            BotEvent::Message(msg) => {
                if msg.is_mine() {
                    return; // never react to our own sends
                }
                let author = short(msg.message.npub.as_deref().unwrap_or("?"));
                let text = msg.text().trim().to_string();
                println!("[MSG]    {author}: {text}");

                // Command console — each arm fires a distinct SDK send-path.
                let ch = msg.channel();
                match text.as_str() {
                    "!help" => reply(&msg, HELP).await,
                    "!ping" => reply(&msg, &format!("pong 🏓 ({} ms)", now_ms())).await,
                    "!reply" => reply(&msg, "this is a threaded reply ✅ (I quoted your message)").await,
                    "!react" => log_err("react", msg.react("🔥").await.map(|_| String::new())),
                    "!typing" => log_err("typing", ch.typing().await.map(|_| String::new())),
                    "!edit" => {
                        if let Ok(id) = ch.send("editing this in one second…").await {
                            log_err("edit", ch.edit(&id, "edited ✏️ (this text was changed)").await.map(|_| String::new()));
                        }
                    }
                    "!delete" => {
                        if let Ok(id) = ch.send("…this message will self-destruct").await {
                            log_err("delete", ch.delete(&id).await.map(|_| String::new()));
                        }
                    }
                    "!file" => send_test_file(&ch).await,
                    "!members" => {
                        if let Some(community) = msg.community() {
                            let members = community.members().await;
                            let list: Vec<String> = members.iter().map(|m| short(m.npub())).collect();
                            reply(&msg, &format!("{} member(s): {}", members.len(), list.join(", "))).await;
                        } else {
                            reply(&msg, "not in a community here").await;
                        }
                    }
                    "!reconnect" => {
                        // Ops/repro tool: bounce this bot's community relay sockets (a
                        // relay restart or idle drop in miniature) — then a !ping proves
                        // whether the subscription survived the fresh AUTH gate.
                        let bounced = bounce_community_relays().await;
                        reply(&msg, &format!("bounced {bounced} relay socket(s) — send !ping to test the post-reconnect subscription")).await;
                    }
                    "!channels" | "!info" | "!caps" | "!roles" | "!whoami" => diagnostics(&bot, &msg, &text).await,
                    other if other.starts_with('!') => reply(&msg, &format!("unknown command `{other}` — try !help")).await,
                    // Non-command chatter is logged above but never replied to, so
                    // the bot can sit in a busy community without spamming echoes.
                    _ => {}
                }
            }
            BotEvent::MessageUpdate { message, .. } => {
                println!("[UPDATE] {} → \"{}\"  ({} reaction(s))", short(message.npub.as_deref().unwrap_or("?")), message.content, message.reactions.len());
            }
            BotEvent::Delete { message_id, .. } => println!("[DELETE] message {}", short(&message_id)),
            BotEvent::MemberJoin { npub, .. } => println!("[JOIN]   {}", short(&npub)),
            BotEvent::MemberLeave { npub, .. } => println!("[LEAVE]  {}", short(&npub)),
            BotEvent::Typing { npub, .. } => println!("[TYPING] {}", short(&npub)),
            BotEvent::Invite { community_id } => println!("[INVITE] for community {}", short(&community_id)),
            BotEvent::Removed { community_id } => println!("[REMOVED] from community {} — I was kicked/banned", short(&community_id)),
        }
    })
    .await?;

    Ok(())
}

pub async fn delete(&self, message_id: &str) -> Result<()>

Delete a message you sent.

Examples found in repository

examples/concordia.rs (line 211)

async fn main() -> vector_sdk::Result<()> {
    // Identity: VECTOR_NSEC override, else the persisted <data_dir>/identity.nsec
    // (created on first run by the builder). Public invite policy: any member can
    // pull the bot into their community with a direct invite (v1 or v2).
    let mut builder = VectorBot::builder().public();
    if let Ok(nsec) = std::env::var("VECTOR_NSEC") {
        builder = builder.nsec(nsec);
    }
    let bot = builder.build().await?;
    println!("── {NAME} online as {}", bot.npub());

    // Optional one-shot profile publish: upload the avatar plainly (avatars are
    // public) and publish the kind-0 with the bot flag. Existing fields are
    // carried forward by the profile pipeline, so this never clobbers. Deferred
    // until after listen() has connected the community relays — a kind-0 that
    // only reaches the login relays is invisible to community peers' clients.
    if let Ok(avatar_path) = std::env::var("CONCORDIA_AVATAR") {
        let bot = bot.clone();
        tokio::spawn(async move {
            tokio::time::sleep(std::time::Duration::from_secs(10)).await;
            let avatar_path = shellexpand_home(&avatar_path);
            println!("── uploading avatar {avatar_path}…");
            match bot.core().upload_public_image(&avatar_path).await {
                Ok(url) => {
                    let ok = bot.core().update_bot_profile(NAME, &url, "", ABOUT).await;
                    println!("── profile publish {}  avatar={url}", if ok { "✅" } else { "FAILED" });
                    if ok {
                        push_profile_to_communities().await;
                    }
                }
                Err(e) => eprintln!("!! avatar upload failed: {e}"),
            }
        });
    }

    // Optional invite link: join on first run; later runs come up with the
    // persisted memberships and need no arguments.
    if let Some(invite) = std::env::args().nth(1).or_else(|| std::env::var("VECTOR_INVITE").ok()) {
        println!("── joining via link…");
        match bot.core().join_community(&invite).await {
            Ok(summary) => {
                let name = summary.get("name").and_then(|v| v.as_str()).unwrap_or("?");
                let ver = summary.get("version").and_then(|v| v.as_u64()).unwrap_or(0);
                println!("── joined \"{name}\"  protocol=v{ver}");
            }
            Err(e) => {
                eprintln!("!! join failed: {e}");
                return Err(e);
            }
        }
    }

    // Slash commands (Bot Interface Phase 1): registered here, published as the
    // kind-10304 manifest at listen start, invoked by PLAIN TEXT from any client.
    // Vector's `/` picker renders exactly this registry with argument hints; a
    // matched invocation is consumed before the legacy !bang console below.
    bot.command("help", "List everything Concordia can do").run(|ctx| async move {
        let _ = ctx.reply(HELP).await;
    });
    bot.command("ping", "Round-trip latency check").run(|ctx| async move {
        let _ = ctx.reply(format!("pong 🏓 ({} ms)", now_ms())).await;
    });
    bot.command("roll", "Roll a die")
        .int("sides", "How many sides (default 6)", false)
        .run(|ctx| async move {
            let sides = ctx.int("sides").unwrap_or(6).clamp(2, 1_000_000);
            let roll = (now_ms() as i64 % sides) + 1;
            let _ = ctx.reply(format!("🎲 rolled {roll} on a d{sides}")).await;
        });
    bot.command("announce", "Format a two-part announcement")
        .string("title", "Announcement title", true)
        .string("body", "Announcement body", true)
        .run(|ctx| async move {
            let title = ctx.str("title").unwrap_or("(untitled)").to_string();
            let body = ctx.str("body").unwrap_or_default().to_string();
            let _ = ctx.reply(format!("📣 {title}\n{body}")).await;
        });
    // ── Param-type test battery: every ArgType, solo and mixed ──────────────
    bot.command("typetest", "Echo back every param type, parsed")
        .string("text", "Any free text", true)
        .int("count", "A whole number", true)
        .number("ratio", "A decimal number", true)
        .flag("loud", "true or false", true)
        .user("who", "Any user (npub)", true)
        .choice("color", "Pick a color", ["red", "green", "blue"], true)
        .run(|ctx| async move {
            let report = format!(
                "typetest received:\n\
                 text   (String) = {:?}\n\
                 count  (Int)    = {}\n\
                 ratio  (Number) = {}\n\
                 loud   (Bool)   = {}\n\
                 who    (User)   = {}\n\
                 color  (Choice) = {}",
                ctx.str("text").unwrap_or_default(),
                ctx.int("count").unwrap_or_default(),
                ctx.number("ratio").unwrap_or_default(),
                ctx.flag("loud").unwrap_or_default(),
                ctx.str("who").unwrap_or_default(),
                ctx.str("color").unwrap_or_default(),
            );
            let _ = ctx.reply(report).await;
        });
    bot.command("greet", "Greet a member in a chosen style")
        .user("who", "Who to greet", true)
        .choice("style", "Greeting style", ["formal", "casual", "pirate"], true)
        .int("times", "Repeat 1-5 times (default 1)", false)
        .run(|ctx| async move {
            let who = ctx.str("who").unwrap_or_default().to_string();
            let line = match ctx.str("style").unwrap_or("casual") {
                "formal" => format!("Good day to you, {who}."),
                "pirate" => format!("Ahoy, {who}! 🏴‍☠️"),
                _ => format!("yo {who} 👋"),
            };
            let times = ctx.int("times").unwrap_or(1).clamp(1, 5) as usize;
            let _ = ctx.reply(vec![line; times].join("\n")).await;
        });
    bot.command("calc", "Do some arithmetic")
        .number("a", "First operand", true)
        .choice("op", "Operation", ["add", "sub", "mul", "div"], true)
        .number("b", "Second operand", true)
        .run(|ctx| async move {
            let a = ctx.number("a").unwrap_or_default();
            let b = ctx.number("b").unwrap_or_default();
            let answer = match ctx.str("op").unwrap_or_default() {
                "add" => Some(a + b),
                "sub" => Some(a - b),
                "mul" => Some(a * b),
                "div" if b != 0.0 => Some(a / b),
                _ => None,
            };
            let _ = ctx
                .reply(match answer {
                    Some(v) => format!("🧮 {v}"),
                    None => "cannot divide by zero".to_string(),
                })
                .await;
        });

    bot.command("reply", "Get a threaded reply to your message").run(|ctx| async move {
        let _ = ctx.reply("this is a threaded reply ✅ (I quoted your message)").await;
    });
    bot.command("react", "React to your message")
        .choice("emoji", "Which reaction", ["🔥", "👍", "❤️", "😂", "🫡"], false)
        .run(|ctx| async move {
            let emoji = ctx.str("emoji").unwrap_or("🔥").to_string();
            log_err("react", ctx.msg.react(&emoji).await.map(|_| String::new()));
        });
    bot.command("edit", "Watch me send then edit a message").run(|ctx| async move {
        let ch = ctx.msg.channel();
        if let Ok(id) = ch.send("editing this in one second…").await {
            log_err("edit", ch.edit(&id, "edited ✏️ (this text was changed)").await.map(|_| String::new()));
        }
    });
    bot.command("delete", "Watch a message self-destruct").run(|ctx| async move {
        let ch = ctx.msg.channel();
        if let Ok(id) = ch.send("…this message will self-destruct").await {
            log_err("delete", ch.delete(&id).await.map(|_| String::new()));
        }
    });
    bot.command("typing", "Emit a typing indicator").run(|ctx| async move {
        log_err("typing", ctx.msg.channel().typing().await.map(|_| String::new()));
    });
    bot.command("file", "Receive a small encrypted attachment").run(|ctx| async move {
        send_test_file(&ctx.msg.channel()).await;
    });
    bot.command("members", "The folded member list").run(|ctx| async move {
        if let Some(community) = ctx.msg.community() {
            let members = community.members().await;
            let list: Vec<String> = members.iter().map(|m| short(m.npub())).collect();
            let _ = ctx.reply(format!("{} member(s): {}", members.len(), list.join(", "))).await;
        } else {
            let _ = ctx.reply("not in a community here").await;
        }
    });
    bot.command("channels", "The channels I can see here").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!channels").await;
    });
    bot.command("caps", "My capabilities here (roles engine)").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!caps").await;
    });
    bot.command("roles", "The community roster").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!roles").await;
    });
    bot.command("info", "Community protocol + ownership summary").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!info").await;
    });
    bot.command("whoami", "My npub and this channel id").run(|ctx| async move {
        diagnostics(&ctx.bot, &ctx.msg, "!whoami").await;
    });
    bot.command("reconnect", "Bounce my relay sockets (reconnect drill)").run(|ctx| async move {
        let bounced = bounce_community_relays().await;
        let _ = ctx.reply(format!("bounced {bounced} relay socket(s) — /ping to test the post-reconnect subscription")).await;
    });

    // The join snapshot folds only owner-authored channels; admin-created ones
    // arrive on the first control follow, so re-print once that has landed.
    print_channels(&bot, "channels visible (startup)").await;
    {
        let bot = bot.clone();
        tokio::spawn(async move {
            tokio::time::sleep(std::time::Duration::from_secs(25)).await;
            print_channels(&bot, "channels visible (after control follow)").await;
        });
    }
    println!("── listening. Message me `!help` from your client.\n");

    bot.on_event(|bot, event| async move {
        match event {
            BotEvent::Message(msg) => {
                if msg.is_mine() {
                    return; // never react to our own sends
                }
                let author = short(msg.message.npub.as_deref().unwrap_or("?"));
                let text = msg.text().trim().to_string();
                println!("[MSG]    {author}: {text}");

                // Command console — each arm fires a distinct SDK send-path.
                let ch = msg.channel();
                match text.as_str() {
                    "!help" => reply(&msg, HELP).await,
                    "!ping" => reply(&msg, &format!("pong 🏓 ({} ms)", now_ms())).await,
                    "!reply" => reply(&msg, "this is a threaded reply ✅ (I quoted your message)").await,
                    "!react" => log_err("react", msg.react("🔥").await.map(|_| String::new())),
                    "!typing" => log_err("typing", ch.typing().await.map(|_| String::new())),
                    "!edit" => {
                        if let Ok(id) = ch.send("editing this in one second…").await {
                            log_err("edit", ch.edit(&id, "edited ✏️ (this text was changed)").await.map(|_| String::new()));
                        }
                    }
                    "!delete" => {
                        if let Ok(id) = ch.send("…this message will self-destruct").await {
                            log_err("delete", ch.delete(&id).await.map(|_| String::new()));
                        }
                    }
                    "!file" => send_test_file(&ch).await,
                    "!members" => {
                        if let Some(community) = msg.community() {
                            let members = community.members().await;
                            let list: Vec<String> = members.iter().map(|m| short(m.npub())).collect();
                            reply(&msg, &format!("{} member(s): {}", members.len(), list.join(", "))).await;
                        } else {
                            reply(&msg, "not in a community here").await;
                        }
                    }
                    "!reconnect" => {
                        // Ops/repro tool: bounce this bot's community relay sockets (a
                        // relay restart or idle drop in miniature) — then a !ping proves
                        // whether the subscription survived the fresh AUTH gate.
                        let bounced = bounce_community_relays().await;
                        reply(&msg, &format!("bounced {bounced} relay socket(s) — send !ping to test the post-reconnect subscription")).await;
                    }
                    "!channels" | "!info" | "!caps" | "!roles" | "!whoami" => diagnostics(&bot, &msg, &text).await,
                    other if other.starts_with('!') => reply(&msg, &format!("unknown command `{other}` — try !help")).await,
                    // Non-command chatter is logged above but never replied to, so
                    // the bot can sit in a busy community without spamming echoes.
                    _ => {}
                }
            }
            BotEvent::MessageUpdate { message, .. } => {
                println!("[UPDATE] {} → \"{}\"  ({} reaction(s))", short(message.npub.as_deref().unwrap_or("?")), message.content, message.reactions.len());
            }
            BotEvent::Delete { message_id, .. } => println!("[DELETE] message {}", short(&message_id)),
            BotEvent::MemberJoin { npub, .. } => println!("[JOIN]   {}", short(&npub)),
            BotEvent::MemberLeave { npub, .. } => println!("[LEAVE]  {}", short(&npub)),
            BotEvent::Typing { npub, .. } => println!("[TYPING] {}", short(&npub)),
            BotEvent::Invite { community_id } => println!("[INVITE] for community {}", short(&community_id)),
            BotEvent::Removed { community_id } => println!("[REMOVED] from community {} — I was kicked/banned", short(&community_id)),
        }
    })
    .await?;

    Ok(())
}

pub async fn send_file(&self, path: impl AsRef<Path>) -> Result<String>

Send a file from disk as an encrypted attachment — works for DMs and Community channels.

Examples found in repository

examples/concordia.rs (line 448)

async fn send_test_file(ch: &vector_sdk::Channel) {
    let path = std::env::temp_dir().join(format!("concordia_{}.txt", now_ms()));
    if let Err(e) = std::fs::write(&path, format!("Hello from {NAME}!\nsent at {} ms\n", now_ms())) {
        eprintln!("!! temp file write failed: {e}");
        return;
    }
    log_err("send_file", ch.send_file(&path).await.map(|_| String::new()));
    let _ = std::fs::remove_file(&path);
}

examples/file_bot.rs (line 28)

async fn main() -> vector_sdk::Result<()> {
    let nsec = std::env::var("VECTOR_NSEC").expect("set VECTOR_NSEC to your bot's nsec");
    let target = std::env::var("VECTOR_TARGET").expect("set VECTOR_TARGET to a recipient npub");
    let file = std::env::var("VECTOR_FILE").expect("set VECTOR_FILE to a file path");

    let bot = VectorBot::builder().nsec(nsec).build().await?;
    println!("Sending {} as {}", file, bot.npub());

    // Give the relay connections a moment to come up before the first send.
    tokio::time::sleep(Duration::from_secs(2)).await;

    let event_id = bot.channel(&target).send_file(&file).await?;
    println!("Sent — event id: {}", event_id);

    Ok(())
}

Trait Implementations

impl Clone for Channel

fn clone(&self) -> Channel

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.