pi-roundtable 0.31.1 → 0.31.2

package/CHANGELOG.md

@@ -5,6 +5,13 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.31.2] - 2026-11-02
+
+### Added
+
+- `PeerBotEntry.yields`: a host leaves to a listed peer bot a person's message that addresses both. When a person mentions or replies to the host and in the same message mentions that bot or replies to its message, where the entry lists the bot and not in a direct conversation, the host starts no turn and logs `message left to a peer bot`; observers still hear the message. Only the peer answers, and it hands over by mentioning the host, whose answer to a listed peer is unchanged. Set it on one side only: two hosts that yield to each other both stay silent.
+- `InboundMessage.mentionedUserIds?` (every user the message mentions, the bot among them) and `InboundMessage.reference.authorId?` (who wrote the replied-to message), both set by the Discord surface.
+
 ## [0.31.1] - 2026-11-01
 
 - Release in lockstep with pi-roundtable-web 0.31.1 (the animated scene's progress strip names the member at work and folds to one line); no core behavior changes.

package/docs/plugins.md

@@ -2868,6 +2868,12 @@ The router, not each claim, applies the list: for a message from a listed bot it
 A channel answers at most `maxRounds` of the listed bots' messages in a row, counted when a claim takes the message; a person's message in the channel starts the count over, and the messages after the cap are ignored (logged at info).
 Channel context is unchanged: its window still starts after the assistant's last post and other bots' messages are still cut at `botMessageChars`.
 
+When a person addresses two bots in one message, both would answer. An entry with `yields: true` makes the host leave such a message to that peer: a person's message (not in a direct conversation) that mentions or replies to the host and also mentions the peer or replies to its message, in a channel the entry covers, starts no turn here (logged at info as `message left to a peer bot`; observers still hear it). The peer answers alone and hands over by mentioning the host, which answers a listed peer as usual. Set it on one host only, and scope the entry with `guilds` or `channels` to where the peer actually answers; two hosts that yield to each other both stay silent. The router reads `InboundMessage.mentionedUserIds` (every user the message mentions) and `InboundMessage.reference.authorId` (who wrote the replied-to message), which the Discord surface sets.
+
+```ts
+peerBots: { allow: [{ id: "800000000000000002", channels: ["700000000000000001"], yields: true }] },
+```
+
 The agent server answers a peer that mentions the agent or replies to it, like a guest. A listed peer's `speaker` is resolved like a person's, so a claim that checks only `speaker` answers it too. A claim of your own opts in where it once checked `!message.authorIsBot`, with `answersAuthor(message)` from `pi-roundtable/kit`, which is true for a person and for a flagged peer that mentions the bot or replies to it:
 
 ```ts

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-roundtable",
-	"version": "0.31.1",
+	"version": "0.31.2",
 	"description": "A plugin-driven Pi agent server for one owner, reached through Discord or the web",
 	"type": "module",
 	"license": "MIT",

package/src/core/contract/channels.ts

@@ -91,6 +91,11 @@ export interface InboundMessage {
 	 */
 	integration?: { id: string; own: boolean };
 	mentionsBot: boolean;
+	/**
+	 * Every user the message mentions, the bot among them, in the surface's ids; absent when the
+	 * surface does not report them. The router reads it for `peerBots` entries that yield.
+	 */
+	mentionedUserIds?: readonly string[];
 	/** The message replies to one of the bot's messages. */
 	repliesToBot: boolean;
 	/** Message text with the bot mention removed. */
@@ -100,6 +105,8 @@ export interface InboundMessage {
 	reference?: {
 		text: string;
 		attachments: AttachmentRef[];
+		/** The surface's id of the referenced message's author, when the surface reports it. */
+		authorId?: string;
 		/** The name a webhook posted the referenced message under, such as an agent's. */
 		webhookName?: string;
 	};

package/src/core/discord/inbound-message.ts

@@ -30,6 +30,7 @@ function referenceOf(referenced: Message, mention: RegExp) {
 			.replace(mention, "")
 			.trim(),
 		attachments: attachmentRefs(referenced),
+		authorId: referenced.author.id,
 		...(referenced.webhookId
 			? { webhookName: referenced.author.username }
 			: {}),
@@ -121,6 +122,7 @@ export async function toInbound(
 		...(thread ? { thread } : {}),
 		...(message.guildId ? { space: message.guildId } : {}),
 		mentionsBot: message.mentions.users.has(botId),
+		mentionedUserIds: [...message.mentions.users.keys()],
 		repliesToBot: referenced?.author.id === botId,
 		text: withEmbeds(message.content, message.embeds)
 			.replace(mention, "")

package/src/core/routing/channel-router.ts

@@ -131,6 +131,14 @@ export class ChannelRouter implements ConversationPort {
 		// A bot nobody lists is not heard, as it is not answered; a listed peer is, rounds or not.
 		if (!message.authorIsBot || message.peerBot || message.integration)
 			this.#options.observers?.notify(message);
+		const yieldedTo = peers?.yieldsTo(message);
+		if (yieldedTo) {
+			this.#options.logger.info(
+				{ channel: message.channel, bot: yieldedTo },
+				"message left to a peer bot: it also addresses a peer this host yields to",
+			);
+			return;
+		}
 		const started = await this.#inOrder(message.channel, async () => {
 			if (listed && peers?.exhausted(message.channel)) {
 				this.#options.logger.info(

package/src/core/routing/peer-bots.ts

@@ -1,4 +1,5 @@
 import {
+	bool,
 	either,
 	type Field,
 	integer,
@@ -20,6 +21,14 @@ export interface PeerBotEntry {
 	guilds?: readonly string[];
 	/** Answer it only in these channels; left out, in every channel. */
 	channels?: readonly string[];
+	/**
+	 * Leave to this bot a person's message that addresses both: when a person mentions or replies to
+	 * the host and in the same message mentions this bot or replies to it, the host starts no turn
+	 * (observers still hear the message), so only this bot answers and it can hand over by mentioning
+	 * the host. Where `guilds` and `channels` do not list the bot, the host does not yield to it.
+	 * Set it on one side only: two hosts that yield to each other both stay silent.
+	 */
+	yields?: boolean;
 }
 
 /**
@@ -58,6 +67,7 @@ const entryShape = shape({
 	id: snowflake,
 	guilds: optional(list(snowflake)),
 	channels: optional(list(snowflake)),
+	yields: optional(bool),
 });
 
 /** `discord.peerBots`, or the `peerBots` of the host's options. */
@@ -93,13 +103,35 @@ export class PeerBots {
 	/** Whether the host lists the bot that wrote this message, for this channel and server. */
 	lists(message: InboundMessage): boolean {
 		if (!message.authorIsBot || message.integration) return false;
+		return this.#listsHere(message.authorId, message) !== undefined;
+	}
+
+	/**
+	 * The peer bot a person's message addressed to the host is left to: one the host lists here with
+	 * `yields` that the message also mentions or replies to; undefined when the host answers it.
+	 */
+	yieldsTo(message: InboundMessage): string | undefined {
+		// The peer cannot answer in a direct conversation, so the host never yields one.
+		if (message.authorIsBot || message.integration || message.isDirect)
+			return undefined;
+		if (!message.mentionsBot && !message.repliesToBot) return undefined;
+		const addressed = new Set(message.mentionedUserIds ?? []);
+		if (message.reference?.authorId) addressed.add(message.reference.authorId);
+		for (const id of addressed)
+			if (this.#listsHere(id, message)?.yields) return id;
+		return undefined;
+	}
+
+	/** The bot's entry that covers this message's channel and server, preferring one that yields. */
+	#listsHere(botId: string, message: InboundMessage): PeerBotEntry | undefined {
 		const { surface, id: channelId } = parseChannelKey(message.channel);
-		if (surface !== this.#surface) return false;
-		return (this.#entries.get(message.authorId) ?? []).some(
+		if (surface !== this.#surface) return undefined;
+		const here = (this.#entries.get(botId) ?? []).filter(
 			(entry) =>
 				(!entry.guilds || entry.guilds.includes(message.space ?? "")) &&
 				(!entry.channels || entry.channels.includes(channelId)),
 		);
+		return here.find((entry) => entry.yields) ?? here[0];
 	}
 
 	/** Whether the channel has answered its rounds of peer bots since a person last posted. */