@friendlyrobot/discord-pi-agent 0.9.3 → 0.9.5

package/dist/index.js

@@ -101,6 +101,7 @@ async function collectReply(session, prompt, options = {}) {
   let toolCount = 0;
   let sawAgentEnd = false;
   const model = session.model ? `${session.model.provider}/${session.model.id}` : "none";
+  console.info(prompt);
   logger3.debug({
     logPrefix,
     promptLength: prompt.length,
@@ -148,34 +149,16 @@ async function collectReply(session, prompt, options = {}) {
   const errorMessage = session.agent.state.errorMessage?.trim();
   const fallbackText = getLatestAssistantText(session.messages);
   const finalText = streamedText.trim() || fallbackText.trim();
-  logger3.debug({
-    eventCount,
-    toolCount,
-    sawAgentEnd,
-    streamedTextLength: streamedText.trim().length,
-    fallbackTextLength: fallbackText.trim().length,
-    errorMessage,
-    model,
-    logPrefix
-  }, "prompt done");
   if (errorMessage) {
     return errorMessage;
   }
   if (finalText) {
     const transformed = await transformMarkdownTablesToCodeBlocks(finalText);
-    console.info(`========== reply-buffer BEFORE (${finalText.length} chars) ==========
-${finalText}
-========== reply-buffer BEFORE END ==========`);
-    console.info(`========== reply-buffer AFTER  (${transformed.length} chars) ==========
-${transformed}
-========== reply-buffer AFTER END ==========`);
-    logger3.debug({
-      logPrefix,
-      model,
-      finalTextLength: finalText.length,
-      transformedTextLength: transformed.length,
-      transformed: transformed !== finalText
-    }, "assistant text ready");
+    console.info(`========== BEFORE ==========`);
+    console.info(finalText);
+    console.info(`========== TRANSFORMED ==========`);
+    console.info(transformed);
+    console.info(`========== END ==========`);
     return transformed;
   }
   return "No response generated.";
@@ -973,7 +956,6 @@ async function removeWorkingReaction(message) {
 var TYPING_INTERVAL_MS = 9000;
 var typingIntervals = new Map;
 async function sendTypingSafe(channel, channelKey) {
-  logger5.info({ channelKey }, "[TYPING] calling sendTyping()");
   try {
     const token = channel.client.token;
     const url = `https://discord.com/api/v10/channels/${channel.id}/typing`;
@@ -981,23 +963,41 @@ async function sendTypingSafe(channel, channelKey) {
       method: "POST",
       headers: { Authorization: `Bot ${token}` }
     });
-    const body = await res.text();
-    logger5.info({ channelKey, status: res.status, headers: Object.fromEntries(res.headers.entries()), body }, "[TYPING] raw fetch response");
     if (res.ok) {
-      logger5.info({ channelKey }, "[TYPING] raw fetch OK — Discord accepted typing");
+      logger5.debug({ channelKey }, "[TYPING] OK");
+      return;
     }
+    if (res.status === 429) {
+      const body = await res.text();
+      let retryMs = 3000;
+      try {
+        const parsed = JSON.parse(body);
+        if (typeof parsed.retry_after === "number") {
+          retryMs = parsed.retry_after * 1000 + 500;
+        }
+      } catch {}
+      logger5.warn({ channelKey, retryMs }, "[TYPING] 429, retrying after delay");
+      await new Promise((resolve) => setTimeout(resolve, retryMs));
+      await fetch(url, {
+        method: "POST",
+        headers: { Authorization: `Bot ${token}` }
+      });
+      logger5.info({ channelKey }, "[TYPING] retry done");
+      return;
+    }
+    logger5.warn({ channelKey, status: res.status }, "[TYPING] unexpected status");
   } catch (error) {
-    logger5.warn({ channelKey, error }, "[TYPING] sendTyping() FAILED");
+    logger5.warn({ channelKey, error }, "[TYPING] FAILED");
   }
 }
 function startTypingForChannel(channel, channelKey) {
   const existing = typingIntervals.get(channelKey);
   if (existing) {
     existing.refs += 1;
-    logger5.info({ channelKey, refs: existing.refs }, "[TYPING] ref++ (reusing existing interval)");
+    logger5.debug({ channelKey, refs: existing.refs }, "[TYPING] ref++ (reusing existing interval)");
     return;
   }
-  logger5.info({ channelKey }, "[TYPING] started new interval");
+  logger5.debug({ channelKey }, "[TYPING] started new interval");
   sendTypingSafe(channel, channelKey);
   const interval = setInterval(() => {
     sendTypingSafe(channel, channelKey);
@@ -1007,16 +1007,16 @@ function startTypingForChannel(channel, channelKey) {
 function stopTypingForChannel(channelKey) {
   const entry = typingIntervals.get(channelKey);
   if (!entry) {
-    logger5.info({ channelKey }, "[TYPING] stop called but no entry found");
+    logger5.debug({ channelKey }, "[TYPING] stop called but no entry found");
     return;
   }
   entry.refs -= 1;
   if (entry.refs <= 0) {
     clearInterval(entry.interval);
     typingIntervals.delete(channelKey);
-    logger5.info({ channelKey }, "[TYPING] interval cleared (refs hit 0)");
+    logger5.debug({ channelKey }, "[TYPING] interval cleared (refs hit 0)");
   } else {
-    logger5.info({ channelKey, refs: entry.refs }, "[TYPING] ref-- (interval still active)");
+    logger5.debug({ channelKey, refs: entry.refs }, "[TYPING] ref-- (interval still active)");
   }
 }
 async function sendReply(message, text) {
@@ -1028,21 +1028,20 @@ async function sendReply(message, text) {
     return;
   }
   const chunks = chunkMessage(text);
-  logger5.debug({
-    direction: "OUT",
-    messageId: message.id,
-    chunkCount: chunks.length,
-    textLength: text.length
-  }, "sending reply");
+  logger5.debug("sending reply");
   const [firstChunk, ...remainingChunks] = chunks;
   if (!firstChunk) {
     return;
   }
   try {
+    console.info("=== Reply Start ===");
     await message.reply(firstChunk);
+    console.info(firstChunk);
     for (const chunk of remainingChunks) {
+      console.info(chunk);
       await channel.send(chunk);
     }
+    console.info("=== Reply End ===");
   } catch (error) {
     logger5.error({
       messageId: message.id,
@@ -1130,6 +1129,11 @@ async function onMessage(message, config, agentService, sessionRegistry, authCon
     channelType: message.channel.type,
     content
   }, "message received");
+  const channelKey = message.channel.id;
+  const canSend = message.channel.isSendable();
+  if (canSend) {
+    startTypingForChannel(message.channel, channelKey);
+  }
   const { entry, created } = await sessionRegistry.getOrCreate(scope);
   const { session, promptQueue } = entry;
   if (created && scope.startsWith("thread:") && message.channel.isThread()) {
@@ -1138,13 +1142,6 @@ async function onMessage(message, config, agentService, sessionRegistry, authCon
       threadName: message.channel.name
     }, "new thread session");
   }
-  const channelKey = message.channel.id;
-  const canSend = message.channel.isSendable();
-  logger5.info({ channelKey, scope, canSend, channelType: message.channel.type }, "[TYPING] checking sendable");
-  if (canSend) {
-    startTypingForChannel(message.channel, channelKey);
-    logger5.info({ channelKey, scope }, "[TYPING] interval requested");
-  }
   const commandResult = await handleCommand(content, {
     agentService,
     promptQueue,
@@ -1185,11 +1182,6 @@ async function onMessage(message, config, agentService, sessionRegistry, authCon
   }
   await addWorkingReaction(message);
   const queuePosition = promptQueue.getSnapshot().pending;
-  logger5.debug({
-    scope,
-    messageId: message.id,
-    queuePosition
-  }, "enqueue request");
   if (queuePosition > 0) {
     await sendReply(message, `Queued. ${queuePosition} request(s) ahead of this one.`);
   }
@@ -1200,26 +1192,16 @@ async function onMessage(message, config, agentService, sessionRegistry, authCon
         messageId: message.id,
         scope
       }, "processing message");
-      logger5.info({ messageId: message.id, scope, channelKey }, "[TYPING] prompt enqueued, starting processing");
       const promptContent = buildDiscordPromptContent(message, scope, content, config);
       const transformedPrompt = await config.promptTransform(promptContent);
-      logger5.info({ messageId: message.id, scope, channelKey }, "[TYPING] about to call collectReply/session.prompt");
       return collectReply(session, transformedPrompt, {
         logPrefix: `[agent:${session.sessionId}]`
       });
     });
   } finally {
     stopTypingForChannel(channelKey);
-    logger5.info({ channelKey, scope }, "[TYPING] interval released");
     await removeWorkingReaction(message);
   }
-  logger5.info({
-    direction: "OUT",
-    scope,
-    messageId: message.id,
-    responseLength: response.length,
-    response
-  }, "response ready");
   await sendReply(message, response);
 }
 

package/package.json

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