@friendlyrobot/discord-pi-agent 0.21.4 → 0.22.1

package/dist/agent-turn-runner.d.ts

@@ -1,7 +1,14 @@
 import type { AgentSession } from "@earendil-works/pi-coding-agent";
 import type { ImageContent } from "@earendil-works/pi-ai";
+type ToolLifecycleEvent = {
+    toolName: string;
+    toolCallId: string;
+    isError?: boolean;
+};
 type CollectReplyOptions = {
     images?: ImageContent[];
+    onToolStart?: (event: ToolLifecycleEvent) => void | Promise<void>;
+    onToolEnd?: (event: ToolLifecycleEvent) => void | Promise<void>;
 };
 export declare function runAgentTurn(session: AgentSession, prompt: string, options?: CollectReplyOptions): Promise<string>;
 export {};

package/dist/agent-turn-runner.js

@@ -33,6 +33,10 @@ export async function runAgentTurn(session, prompt, options = {}) {
             toolCount += 1;
             const input = event.toolName === "bash" ? event.args.command : event.args;
             toolInputsByCallId.set(event.toolCallId, input);
+            void options.onToolStart?.({
+                toolName: event.toolName,
+                toolCallId: event.toolCallId,
+            });
             if (event.toolName === "bash") {
                 debugPrint(input, "CMD");
                 // logger.debug(
@@ -52,6 +56,11 @@ export async function runAgentTurn(session, prompt, options = {}) {
         if (event.type === "tool_execution_end") {
             const input = toolInputsByCallId.get(event.toolCallId);
             toolInputsByCallId.delete(event.toolCallId);
+            void options.onToolEnd?.({
+                toolName: event.toolName,
+                toolCallId: event.toolCallId,
+                isError: event.isError,
+            });
             if (event.toolName === "bash") {
                 debugPrint(extractToolOutput(event.result), event.isError ? "BASH TOOL ERROR OUTPUT" : "BASH TOOL OUTPUT");
                 // logger.debug(

package/dist/discord-message-handler.js

@@ -1,13 +1,20 @@
 import { readMediaAttachments, readTextAttachments, } from "./discord-attachments";
 import { isAuthorizedMessage, resolveMessageScope } from "./discord-auth";
 import { resolveMediaAttachmentsForPrompt } from "./discord-media-resolution";
-import { addWorkingReaction, removeWorkingReaction, sendCommandReply, sendReply, } from "./discord-replies";
+import { addReaction, addWorkingReaction, removeReaction, removeWorkingReaction, sendCommandReply, sendReply, } from "./discord-replies";
 import { executeSessionCommand } from "./session-commands";
 import { startTypingForChannel, stopTypingForChannel } from "./discord-typing";
 import { createModuleLogger } from "./logger";
 import { buildDiscordMessageMetadata, formatDiscordPromptTime, wrapXmlTag, } from "./prompt-context";
 import { runAgentTurn } from "./agent-turn-runner";
 const logger = createModuleLogger("discord-message-handler");
+const TOOL_REACTION_EMOJIS = {
+    bash: "🖥️",
+    edit: "✏️",
+    read: "👀",
+    write: "📝",
+};
+const DEFAULT_TOOL_REACTION_EMOJI = "🔧";
 export async function handleDiscordMessage(message, config, agentService, sessionRegistry, accessConfig) {
     const preparedMessage = await prepareDiscordMessage(message, accessConfig);
     if (!preparedMessage) {
@@ -134,6 +141,9 @@ async function archiveThreadSession(message, sessionRegistry, scope, commandResu
     }
     await sessionRegistry.remove(scope);
 }
+function resolveToolReactionEmoji(toolName) {
+    return TOOL_REACTION_EMOJIS[toolName] ?? DEFAULT_TOOL_REACTION_EMOJI;
+}
 async function processAgentPrompt(message, config, agentService, entry, preparedMessage, channelKey) {
     if (!message.channel.isSendable()) {
         stopTypingForChannel(channelKey);
@@ -142,17 +152,46 @@ async function processAgentPrompt(message, config, agentService, entry, prepared
     }
     await addWorkingReaction(message, entry.workingEmoji);
     await notifyIfPromptQueued(message, entry.promptQueue.getSnapshot().pending);
+    const toolEmojiByCallId = new Map();
+    const activeToolCountByEmoji = new Map();
     try {
         const response = await entry.promptQueue.enqueue(async () => {
             const promptInput = await buildPromptInput(message, config, agentService, entry, preparedMessage);
             return runAgentTurn(entry.session, promptInput.prompt, {
                 images: promptInput.images,
+                onToolStart: async ({ toolName, toolCallId }) => {
+                    const emoji = resolveToolReactionEmoji(toolName);
+                    toolEmojiByCallId.set(toolCallId, emoji);
+                    const activeCount = activeToolCountByEmoji.get(emoji) ?? 0;
+                    activeToolCountByEmoji.set(emoji, activeCount + 1);
+                    if (activeCount === 0) {
+                        await addReaction(message, emoji);
+                    }
+                },
+                onToolEnd: async ({ toolCallId }) => {
+                    const emoji = toolEmojiByCallId.get(toolCallId);
+                    if (!emoji) {
+                        return;
+                    }
+                    toolEmojiByCallId.delete(toolCallId);
+                    const activeCount = activeToolCountByEmoji.get(emoji) ?? 0;
+                    if (activeCount <= 1) {
+                        activeToolCountByEmoji.delete(emoji);
+                        await removeReaction(message, emoji);
+                        return;
+                    }
+                    activeToolCountByEmoji.set(emoji, activeCount - 1);
+                },
             });
         });
         await sendReply(message, response);
     }
     finally {
         stopTypingForChannel(channelKey);
+        const activeEmojis = Array.from(activeToolCountByEmoji.keys());
+        await Promise.all(activeEmojis.map(async (emoji) => {
+            await removeReaction(message, emoji);
+        }));
         await removeWorkingReaction(message, entry.workingEmoji);
     }
 }

package/dist/discord-replies.d.ts

@@ -1,5 +1,7 @@
 import type { Message } from "discord.js";
 export declare const DEFAULT_WORKING_EMOJI = "\u2699\uFE0F";
+export declare function addReaction(message: Message, emoji: string): Promise<void>;
+export declare function removeReaction(message: Message, emoji: string): Promise<void>;
 export declare function addWorkingReaction(message: Message, emoji?: string): Promise<void>;
 export declare function removeWorkingReaction(message: Message, emoji?: string): Promise<void>;
 export declare function sendReply(message: Message, text: string): Promise<void>;

package/dist/discord-replies.js

@@ -35,25 +35,59 @@ function chunkByLines(text, maxSize) {
     return chunks;
 }
 export const DEFAULT_WORKING_EMOJI = "⚙️";
-export async function addWorkingReaction(message, emoji = DEFAULT_WORKING_EMOJI) {
+function normalizeEmoji(value) {
+    return value.normalize("NFKC").replace(/\uFE0F/g, "");
+}
+function findReactionByEmoji(message, emoji) {
+    const directMatch = message.reactions.cache.get(emoji);
+    if (directMatch) {
+        return directMatch;
+    }
+    const normalizedEmoji = normalizeEmoji(emoji);
+    const normalizedMatch = Array.from(message.reactions.cache.entries()).find(([key, reaction]) => {
+        if (normalizeEmoji(String(key)) === normalizedEmoji) {
+            return true;
+        }
+        if (typeof reaction.emoji?.name === "string") {
+            return normalizeEmoji(reaction.emoji.name) === normalizedEmoji;
+        }
+        return false;
+    })?.[1];
+    if (!normalizedMatch) {
+        logger.debug({
+            messageId: message.id,
+            emoji,
+            normalizedEmoji,
+            reactionKeys: Array.from(message.reactions.cache.keys()),
+        }, "reaction not found in cache");
+    }
+    return normalizedMatch;
+}
+export async function addReaction(message, emoji) {
     try {
         await message.react(emoji);
     }
     catch (error) {
-        logger.debug({ messageId: message.id, error }, "failed to add working reaction");
+        logger.debug({ messageId: message.id, emoji, error }, "failed to add reaction");
     }
 }
-export async function removeWorkingReaction(message, emoji = DEFAULT_WORKING_EMOJI) {
+export async function removeReaction(message, emoji) {
     try {
-        const reaction = message.reactions.cache.get(emoji);
+        const reaction = findReactionByEmoji(message, emoji);
         if (reaction) {
             await reaction.users.remove(message.client.user);
         }
     }
     catch (error) {
-        logger.debug({ messageId: message.id, error }, "failed to remove working reaction");
+        logger.debug({ messageId: message.id, emoji, error }, "failed to remove reaction");
     }
 }
+export async function addWorkingReaction(message, emoji = DEFAULT_WORKING_EMOJI) {
+    await addReaction(message, emoji);
+}
+export async function removeWorkingReaction(message, emoji = DEFAULT_WORKING_EMOJI) {
+    await removeReaction(message, emoji);
+}
 export async function sendReply(message, text) {
     const channel = message.channel;
     if (!channel.isSendable()) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@friendlyrobot/discord-pi-agent",
-  "version": "0.21.4",
+  "version": "0.22.1",
   "description": "Reusable Discord gateway for persistent pi agent sessions",
   "license": "MIT",
   "type": "module",