@meetopenbot/slack 0.0.3 → 0.0.5

package/README.md

@@ -4,7 +4,7 @@ Slack specialist agent for OpenBot: Events API ingress, simple LLM replies, and
 
 ## Features (MVP)
 
-- **Ingress** — verify Slack webhooks, dedupe events, turn messages into `agent:invoke`
+- **Ingress** — verify Slack webhooks, dedupe events, prefetch thread/channel context, turn messages into `agent:invoke`
 - **Agent** — OpenAI + Slack MCP tools (`post_message`, `list_channels`, etc.)
 - **Egress** — post inbound-thread replies via `chat.postMessage`
 
@@ -12,7 +12,8 @@ Slack specialist agent for OpenBot: Events API ingress, simple LLM replies, and
 
 1. Create a Slack app with bot scopes:
 
-   - `app_mentions:read`, `chat:write`
+   - `app_mentions:read`, `chat:write`, `channels:history`, `users:read`
+   - For private channels: `groups:history` (bot must be invited)
    - For DMs: `im:history`, `im:read`, `im:write`
 
 2. Add the plugin to `~/.openbot/agents/slack/AGENT.md`:

package/dist/index.js

@@ -4,6 +4,7 @@ import { isCloudMode } from "./cloud-mode.js";
 import { CREDITS_NOT_CONFIGURED_MESSAGE, creditsErrorMessage, resolveCreditsAuthConfig, } from "./credits-auth.js";
 import { DEFAULT_OPENBOT_CHANNEL_ID, formatMissingCredentials, readSlackConfig, resolveOpenBotChannelId, resolveSlackCredentials, } from "./config.js";
 import { resolveModelConfigField } from "./model-registry.js";
+import { buildPromptWithSlackContext } from "./slack-context.js";
 import { postSlackMessage } from "./slack-post.js";
 import { runSlackAgent } from "./slack-agent.js";
 import { verifySlackSignature } from "./slack-verify.js";
@@ -334,12 +335,27 @@ export default definePlugin({
                     : ctx.state.channelId;
                 if (!channelId)
                     return;
+                let prompt = userMessage;
+                if (slackMeta?.channel && slackMeta.ts) {
+                    try {
+                        prompt = await buildPromptWithSlackContext({
+                            token: auth.credentials.botToken,
+                            channel: slackMeta.channel,
+                            messageTs: slackMeta.ts,
+                            threadTs: slackMeta.threadTs,
+                            userMessage,
+                        });
+                    }
+                    catch {
+                        // Fall back to the raw mention if Slack history is unavailable.
+                    }
+                }
                 try {
                     yield* bridgeSystemAgentRun({
                         host,
                         channelId,
                         threadId,
-                        userMessage,
+                        userMessage: prompt,
                         meta: event.meta,
                         publicBaseUrl,
                     });

package/dist/slack-context.js

@@ -0,0 +1,118 @@
+const DEFAULT_CHANNEL_HISTORY_LIMIT = 20;
+const DEFAULT_THREAD_REPLY_LIMIT = 100;
+async function slackApiGet(token, method, params) {
+    const searchParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined)
+            searchParams.set(key, String(value));
+    }
+    const res = await fetch(`https://slack.com/api/${method}?${searchParams}`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    const body = (await res.json());
+    if (!body.ok) {
+        throw new Error(body.error ?? `Slack API ${method} failed (${res.status})`);
+    }
+    return body;
+}
+function isContextMessage(message) {
+    if (message.bot_id)
+        return false;
+    if (message.subtype && message.subtype !== "thread_broadcast")
+        return false;
+    return Boolean(message.text?.trim());
+}
+async function resolveUserDisplayNames(token, userIds) {
+    const names = new Map();
+    const uniqueIds = [...new Set(userIds)];
+    await Promise.all(uniqueIds.map(async (userId) => {
+        try {
+            const body = await slackApiGet(token, "users.info", { user: userId });
+            names.set(userId, body.user?.real_name?.trim() ||
+                body.user?.name?.trim() ||
+                userId);
+        }
+        catch {
+            names.set(userId, userId);
+        }
+    }));
+    return names;
+}
+function formatSlackTimestamp(ts) {
+    if (!ts)
+        return "";
+    const seconds = Number(ts.split(".")[0]);
+    if (!Number.isFinite(seconds))
+        return "";
+    return new Date(seconds * 1000).toISOString();
+}
+function escapeXml(text) {
+    return text
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+function formatContextMessages(messages, userNames) {
+    return messages.map((message) => {
+        const author = message.user
+            ? (userNames.get(message.user) ?? message.user)
+            : "unknown";
+        const when = formatSlackTimestamp(message.ts);
+        const attrs = [
+            `author="${escapeXml(author)}"`,
+            when ? `timestamp="${escapeXml(when)}"` : null,
+        ]
+            .filter(Boolean)
+            .join(" ");
+        return `  <message ${attrs}>${escapeXml(message.text?.trim() ?? "")}</message>`;
+    });
+}
+function formatPromptWithSlackContext(args) {
+    const sourceNote = args.source === "thread"
+        ? "Messages from the Slack thread the user mentioned the bot in."
+        : "Recent messages from the Slack channel before the user's mention.";
+    return [
+        `<slack_context`,
+        `  channel="${escapeXml(args.channel)}"`,
+        `  source="${args.source}"`,
+        `  message_count="${args.messageCount}"`,
+        `  note="Background context fetched from Slack. Summarized conversation history — not the user's direct request.">`,
+        `  <description>${escapeXml(sourceNote)}</description>`,
+        `  <messages>`,
+        ...args.contextMessages,
+        `  </messages>`,
+        `</slack_context>`,
+        ``,
+        `<user_request>`,
+        escapeXml(args.userMessage),
+        `</user_request>`,
+    ].join("\n");
+}
+async function fetchThreadMessages(token, channel, threadTs, limit = DEFAULT_THREAD_REPLY_LIMIT) {
+    const body = await slackApiGet(token, "conversations.replies", { channel, ts: threadTs, limit });
+    return (body.messages ?? []).filter(isContextMessage);
+}
+async function fetchChannelMessagesBefore(token, channel, latestTs, limit = DEFAULT_CHANNEL_HISTORY_LIMIT) {
+    const body = await slackApiGet(token, "conversations.history", { channel, latest: latestTs, inclusive: false, limit });
+    return (body.messages ?? [])
+        .filter(isContextMessage)
+        .reverse();
+}
+export async function buildPromptWithSlackContext(args) {
+    const messages = args.threadTs
+        ? await fetchThreadMessages(args.token, args.channel, args.threadTs)
+        : await fetchChannelMessagesBefore(args.token, args.channel, args.messageTs, args.channelHistoryLimit ?? DEFAULT_CHANNEL_HISTORY_LIMIT);
+    if (messages.length === 0) {
+        return args.userMessage;
+    }
+    const userNames = await resolveUserDisplayNames(args.token, messages.flatMap((message) => (message.user ? [message.user] : [])));
+    const formattedMessages = formatContextMessages(messages, userNames);
+    return formatPromptWithSlackContext({
+        channel: args.channel,
+        source: args.threadTs ? "thread" : "channel",
+        messageCount: messages.length,
+        contextMessages: formattedMessages,
+        userMessage: args.userMessage,
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/slack",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Slack Events API ingress, simple agent replies, and thread delivery for OpenBot",
   "type": "module",
   "main": "dist/index.js",