@poncho-ai/messaging 0.7.10 → 0.8.1

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @poncho-ai/messaging@0.7.10 build /home/runner/work/poncho-ai/poncho-ai/packages/messaging
+> @poncho-ai/messaging@0.8.1 build /home/runner/work/poncho-ai/poncho-ai/packages/messaging
 > tsup src/index.ts --format esm --dts
 
 CLI Building entry: src/index.ts
@@ -7,8 +7,8 @@
 CLI tsup v8.5.1
 CLI Target: es2022
 ESM Build start
-ESM dist/index.js 52.02 KB
-ESM ⚡️ Build success in 128ms
+ESM dist/index.js 53.27 KB
+ESM ⚡️ Build success in 60ms
 DTS Build start
-DTS ⚡️ Build success in 4935ms
+DTS ⚡️ Build success in 5292ms
 DTS dist/index.d.ts 11.66 KB

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @poncho-ai/messaging
 
+## 0.8.1
+
+### Patch Changes
+
+- [`69dd20a`](https://github.com/cesr/poncho-ai/commit/69dd20ae31ada0edaf281cf451729ffe37f4df71) Thanks [@cesr](https://github.com/cesr)! - fix: use GET for Slack conversations.replies API call so thread context is fetched correctly
+
+## 0.8.0
+
+### Minor Changes
+
+- [`fb7ee97`](https://github.com/cesr/poncho-ai/commit/fb7ee97f7df0dda7318a7e59565e0b53285f10c4) Thanks [@cesr](https://github.com/cesr)! - feat: include thread context when Slack bot is @mentioned in a thread reply
+
+  When the bot is @mentioned in a thread (not the parent message), the adapter now fetches prior thread messages via `conversations.replies` and prepends them as context, so the agent understands what the conversation is about.
+
 ## 0.7.10
 
 ### Patch Changes

package/dist/index.js

@@ -203,6 +203,29 @@ var addReaction = async (token, channel, timestamp, reaction) => {
     throw new Error(`Slack reactions.add failed: ${result.error}`);
   }
 };
+var fetchThreadMessages = async (token, channel, threadTs, excludeTs) => {
+  const params = new URLSearchParams({
+    channel,
+    ts: threadTs,
+    limit: "50"
+  });
+  const res = await fetch(
+    `${SLACK_API}/conversations.replies?${params.toString()}`,
+    {
+      method: "GET",
+      headers: { authorization: `Bearer ${token}` }
+    }
+  );
+  const result = await res.json();
+  if (!result.ok) {
+    console.error(
+      `[slack-adapter] conversations.replies failed: ${result.error} \u2014 ensure the bot has the "channels:history" scope`
+    );
+    return [];
+  }
+  const messages = result.messages ?? [];
+  return excludeTs ? messages.filter((m) => m.ts !== excludeTs) : messages;
+};
 var removeReaction = async (token, channel, timestamp, reaction) => {
   const result = await slackFetch("reactions.remove", token, {
     channel,
@@ -335,8 +358,26 @@ var SlackAdapter = class {
         const messageTs = String(event.ts ?? "");
         const channel = String(event.channel ?? "");
         const userId = String(event.user ?? "");
+        let contextPrefix = "";
+        if (event.thread_ts && event.thread_ts !== event.ts) {
+          const threadMessages = await fetchThreadMessages(
+            this.botToken,
+            channel,
+            threadTs,
+            messageTs
+            // exclude the triggering message itself
+          );
+          if (threadMessages.length > 0) {
+            const formatted = threadMessages.map((m) => `<${m.user ?? "unknown"}>: ${m.text ?? ""}`).join("\n");
+            contextPrefix = `[Thread context]
+${formatted}
+
+[New message]
+`;
+          }
+        }
         const message = {
-          text,
+          text: contextPrefix + text,
           threadRef: {
             platformThreadId: threadTs,
             channelId: channel,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@poncho-ai/messaging",
-  "version": "0.7.10",
+  "version": "0.8.1",
   "description": "Messaging platform adapters for Poncho agents (Slack, Telegram, etc.)",
   "repository": {
     "type": "git",

package/src/adapters/slack/index.ts

@@ -9,6 +9,7 @@ import type {
 import { verifySlackSignature } from "./verify.js";
 import {
   addReaction,
+  fetchThreadMessages,
   postMessage,
   removeReaction,
   splitMessage,
@@ -189,8 +190,27 @@ export class SlackAdapter implements MessagingAdapter {
         const channel = String(event.channel ?? "");
         const userId = String(event.user ?? "");
 
+        // When the mention is inside a thread (thread_ts differs from ts),
+        // fetch prior thread messages so the agent has context.
+        let contextPrefix = "";
+        if (event.thread_ts && event.thread_ts !== event.ts) {
+          const threadMessages = await fetchThreadMessages(
+            this.botToken,
+            channel,
+            threadTs,
+            messageTs, // exclude the triggering message itself
+          );
+
+          if (threadMessages.length > 0) {
+            const formatted = threadMessages
+              .map((m) => `<${m.user ?? "unknown"}>: ${m.text ?? ""}`)
+              .join("\n");
+            contextPrefix = `[Thread context]\n${formatted}\n\n[New message]\n`;
+          }
+        }
+
         const message: PonchoIncomingMessage = {
-          text,
+          text: contextPrefix + text,
           threadRef: {
             platformThreadId: threadTs,
             channelId: channel,

package/src/adapters/slack/utils.ts

@@ -90,6 +90,47 @@ export const addReaction = async (
   }
 };
 
+/**
+ * Fetch thread replies using `conversations.replies`.
+ * Returns messages sorted chronologically (oldest first), excluding the
+ * message identified by `excludeTs` (typically the triggering mention).
+ */
+export const fetchThreadMessages = async (
+  token: string,
+  channel: string,
+  threadTs: string,
+  excludeTs?: string,
+): Promise<Array<{ user?: string; text?: string; ts: string }>> => {
+  const params = new URLSearchParams({
+    channel,
+    ts: threadTs,
+    limit: "50",
+  });
+
+  const res = await fetch(
+    `${SLACK_API}/conversations.replies?${params.toString()}`,
+    {
+      method: "GET",
+      headers: { authorization: `Bearer ${token}` },
+    },
+  );
+  const result = (await res.json()) as {
+    ok: boolean;
+    error?: string;
+    messages?: Array<{ user?: string; text?: string; ts: string }>;
+  };
+
+  if (!result.ok) {
+    console.error(
+      `[slack-adapter] conversations.replies failed: ${result.error} — ensure the bot has the "channels:history" scope`,
+    );
+    return [];
+  }
+
+  const messages = result.messages ?? [];
+  return excludeTs ? messages.filter((m) => m.ts !== excludeTs) : messages;
+};
+
 export const removeReaction = async (
   token: string,
   channel: string,

package/test/adapters/slack.test.ts

@@ -238,4 +238,96 @@ describe("SlackAdapter", () => {
     expect(received).toHaveLength(0);
     expect(resStatus()).toBe(200);
   });
+
+  it("includes thread context when mention is in a thread reply", async () => {
+    const adapter = new SlackAdapter();
+    await adapter.initialize();
+    const received: PonchoIncomingMessage[] = [];
+    adapter.onMessage(async (msg) => { received.push(msg); });
+
+    // Mock fetch to intercept conversations.replies
+    const originalFetch = globalThis.fetch;
+    vi.stubGlobal("fetch", vi.fn(async (url: string) => {
+      if (typeof url === "string" && url.includes("conversations.replies")) {
+        return {
+          json: async () => ({
+            ok: true,
+            messages: [
+              { user: "U_PARENT", text: "What are the limitations of self-hosted?", ts: "100.0" },
+              { user: "U2", text: "<@U1> can you help?", ts: "100.1" },
+            ],
+          }),
+        };
+      }
+      // Pass through for other Slack API calls (reactions)
+      return { json: async () => ({ ok: true }) };
+    }));
+
+    let handler: any;
+    adapter.registerRoutes((_m, _p, h) => { handler = h; });
+
+    const body = JSON.stringify({
+      type: "event_callback",
+      event: {
+        type: "app_mention",
+        text: "<@U1> can you help?",
+        ts: "100.1",
+        thread_ts: "100.0",
+        channel: "C1",
+        user: "U2",
+      },
+    });
+    const { req, res } = makeReqRes(body);
+    await handler(req, res);
+
+    // Wait for async handler
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(received).toHaveLength(1);
+    expect(received[0]!.text).toContain("[Thread context]");
+    expect(received[0]!.text).toContain("What are the limitations of self-hosted?");
+    expect(received[0]!.text).toContain("[New message]");
+    expect(received[0]!.text).toContain("can you help?");
+
+    vi.stubGlobal("fetch", originalFetch);
+  });
+
+  it("does not fetch thread context for top-level mentions", async () => {
+    const adapter = new SlackAdapter();
+    await adapter.initialize();
+    const received: PonchoIncomingMessage[] = [];
+    adapter.onMessage(async (msg) => { received.push(msg); });
+
+    const fetchSpy = vi.fn(async () => ({ json: async () => ({ ok: true }) }));
+    vi.stubGlobal("fetch", fetchSpy);
+
+    let handler: any;
+    adapter.registerRoutes((_m, _p, h) => { handler = h; });
+
+    // No thread_ts → top-level message
+    const body = JSON.stringify({
+      type: "event_callback",
+      event: {
+        type: "app_mention",
+        text: "<@U1> hello",
+        ts: "200.0",
+        channel: "C1",
+        user: "U2",
+      },
+    });
+    const { req, res } = makeReqRes(body);
+    await handler(req, res);
+
+    await new Promise((r) => setTimeout(r, 100));
+
+    expect(received).toHaveLength(1);
+    expect(received[0]!.text).toBe("hello");
+    // conversations.replies should NOT have been called
+    const repliesCalls = fetchSpy.mock.calls.filter(
+      ([url]: any) => typeof url === "string" && url.includes("conversations.replies"),
+    );
+    expect(repliesCalls).toHaveLength(0);
+
+    vi.restoreAllMocks();
+  });
 });