@friendlyrobot/discord-pi-agent 0.22.0 → 0.22.2

package/dist/agent-turn-runner.js

@@ -7,6 +7,7 @@ export async function runAgentTurn(session, prompt, options = {}) {
     let eventCount = 0;
     let toolCount = 0;
     const toolInputsByCallId = new Map();
+    const pendingToolLifecycleTasks = new Set();
     const model = session.model
         ? `${session.model.provider}/${session.model.id}`
         : "none";
@@ -33,9 +34,13 @@ 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?.({
+            const onToolStartTask = Promise.resolve(options.onToolStart?.({
                 toolName: event.toolName,
                 toolCallId: event.toolCallId,
+            })).then(() => undefined);
+            pendingToolLifecycleTasks.add(onToolStartTask);
+            void onToolStartTask.finally(() => {
+                pendingToolLifecycleTasks.delete(onToolStartTask);
             });
             if (event.toolName === "bash") {
                 debugPrint(input, "CMD");
@@ -56,10 +61,14 @@ 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?.({
+            const onToolEndTask = Promise.resolve(options.onToolEnd?.({
                 toolName: event.toolName,
                 toolCallId: event.toolCallId,
                 isError: event.isError,
+            })).then(() => undefined);
+            pendingToolLifecycleTasks.add(onToolEndTask);
+            void onToolEndTask.finally(() => {
+                pendingToolLifecycleTasks.delete(onToolEndTask);
             });
             if (event.toolName === "bash") {
                 debugPrint(extractToolOutput(event.result), event.isError ? "BASH TOOL ERROR OUTPUT" : "BASH TOOL OUTPUT");
@@ -97,6 +106,7 @@ export async function runAgentTurn(session, prompt, options = {}) {
     });
     try {
         await session.prompt(prompt, { images: options.images });
+        await Promise.allSettled(Array.from(pendingToolLifecycleTasks));
     }
     finally {
         unsubscribe();

package/dist/discord-message-handler.js

@@ -154,33 +154,40 @@ async function processAgentPrompt(message, config, agentService, entry, prepared
     await notifyIfPromptQueued(message, entry.promptQueue.getSnapshot().pending);
     const toolEmojiByCallId = new Map();
     const activeToolCountByEmoji = new Map();
+    let reactionOperationChain = Promise.resolve();
     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);
-                    }
+                    reactionOperationChain = reactionOperationChain.then(async () => {
+                        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);
+                        }
+                    });
+                    await reactionOperationChain;
                 },
                 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);
+                    reactionOperationChain = reactionOperationChain.then(async () => {
+                        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 reactionOperationChain;
                 },
             });
         });

package/dist/discord-replies.js

@@ -35,6 +35,34 @@ function chunkByLines(text, maxSize) {
     return chunks;
 }
 export const 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);
@@ -45,7 +73,7 @@ export async function addReaction(message, 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);
         }

package/package.json

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