@meetopenbot/slack 0.0.2 → 0.0.4

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,10 +4,12 @@ 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";
 const ROUTING_AGENT_ID = "system";
+const SLACK_USER_DISPLAY_NAME = "Slack user";
 function isSlackWebhookIngress(meta) {
     return meta?.source === "slack";
 }
@@ -79,6 +81,10 @@ async function* bridgeSystemAgentRun(args) {
                 threadId: args.threadId,
                 source: "slack",
                 slack: slackMeta,
+                userName: SLACK_USER_DISPLAY_NAME,
+                ...(typeof args.meta?.userId === "string"
+                    ? { userId: args.meta.userId }
+                    : {}),
             },
         },
         onEvent: async (outEvent) => {
@@ -267,6 +273,8 @@ export default definePlugin({
                     threadId,
                     source: "slack",
                     slack: slackMeta,
+                    userName: SLACK_USER_DISPLAY_NAME,
+                    ...(slackEvent.user ? { userId: slackEvent.user } : {}),
                 },
             };
         });
@@ -327,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,90 @@
+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 formatContextMessages(messages, userNames) {
+    return messages.map((message) => {
+        const author = message.user
+            ? (userNames.get(message.user) ?? message.user)
+            : "unknown";
+        const when = formatSlackTimestamp(message.ts);
+        const prefix = when ? `[${when}] ${author}` : author;
+        return `${prefix}: ${message.text?.trim() ?? ""}`;
+    });
+}
+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);
+    const contextLabel = args.threadTs
+        ? "Slack thread context"
+        : "Recent Slack channel messages";
+    return [
+        `## ${contextLabel}`,
+        `Channel: ${args.channel}`,
+        "",
+        ...formattedMessages,
+        "",
+        "## User request",
+        args.userMessage,
+    ].join("\n");
+}

package/package.json

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