@meetopenbot/slack 0.0.7 → 0.0.8

package/dist/agent.js

@@ -0,0 +1,21 @@
+import { runMcpTurn } from "@meetopenbot/plugin-sdk";
+const SYSTEM_PROMPT = `You are the OpenBot Slack specialist agent.
+Use Slack MCP tools to post messages, list channels, read history, and perform other workspace actions when needed.
+Summarize results clearly in plain text for the user. Be concise and friendly.`;
+export async function runSlackAgent(args) {
+    return runMcpTurn({
+        mcp: {
+            command: "npx",
+            args: ["-y", "@modelcontextprotocol/server-slack"],
+            env: () => ({
+                SLACK_BOT_TOKEN: args.botToken,
+                SLACK_TEAM_ID: args.teamId,
+            }),
+        },
+        apiKey: args.botToken,
+        model: args.model ?? "openai/gpt-4o-mini",
+        system: SYSTEM_PROMPT,
+        prompt: args.prompt,
+        maxSteps: 10,
+    });
+}

package/dist/config.js

@@ -1,125 +1,86 @@
-import { resolveAuthMode } from "./cloud-mode.js";
-import { shouldUseCreditsAuth } from "./credits-auth.js";
+import { lookupSecret, modelConfigField, trimmedString, } from "@meetopenbot/plugin-sdk";
 export const DEFAULT_OPENBOT_CHANNEL_ID = "general";
-/** Parse `C0123:engineering,C0456:support` into a lookup index. */
+export const ROUTING_AGENT_ID = "system";
+export const SLACK_USER_DISPLAY_NAME = "Slack user";
+const modelField = await modelConfigField({
+    providers: ["openai"],
+    override: true,
+    defaultValue: "openai/gpt-4o-mini",
+});
+export const pluginConfigSchema = {
+    type: "object",
+    properties: {
+        model: {
+            ...modelField,
+            description: "Outbound — OpenAI model for direct Slack agent invocations",
+        },
+        channelMappings: {
+            type: "string",
+            description: "Inbound — webhook routing. Comma-separated slackChannelId:openbotChannelId pairs (e.g. C01234567:engineering,C89ABCDEF:support). Unmapped Slack channels use general.",
+        },
+    },
+};
 export function buildSlackChannelMappingIndex(config) {
     const index = new Map();
-    const raw = typeof config.channelMappings === "string"
-        ? config.channelMappings.trim()
-        : "";
+    const raw = trimmedString(config.channelMappings) ?? "";
     if (!raw)
         return index;
     for (const segment of raw.split(",")) {
         const trimmed = segment.trim();
-        if (!trimmed)
-            continue;
         const colon = trimmed.indexOf(":");
         if (colon <= 0 || colon === trimmed.length - 1)
             continue;
         const slackChannelId = trimmed.slice(0, colon).trim();
         const channelId = trimmed.slice(colon + 1).trim();
-        if (!slackChannelId || !channelId)
-            continue;
-        index.set(slackChannelId, channelId);
+        if (slackChannelId && channelId)
+            index.set(slackChannelId, channelId);
     }
     return index;
 }
-/** Map a Slack channel id from webhook ingress to an OpenBot channel id. */
 export function resolveOpenBotChannelId(slackChannelId, config) {
     const normalized = slackChannelId.trim();
     if (!normalized)
         return DEFAULT_OPENBOT_CHANNEL_ID;
-    const mapped = buildSlackChannelMappingIndex(config).get(normalized);
-    return mapped ?? DEFAULT_OPENBOT_CHANNEL_ID;
-}
-function variableValue(variables, key) {
-    const entry = variables[key];
-    if (typeof entry === "string")
-        return entry || undefined;
-    return entry?.value || undefined;
+    return (buildSlackChannelMappingIndex(config).get(normalized) ??
+        DEFAULT_OPENBOT_CHANNEL_ID);
 }
 export function readSlackConfig(config) {
     return {
-        signingSecret: typeof config.signingSecret === "string" && config.signingSecret.trim()
-            ? config.signingSecret.trim()
-            : undefined,
-        botToken: typeof config.botToken === "string" && config.botToken.trim()
-            ? config.botToken.trim()
-            : undefined,
-        teamId: typeof config.teamId === "string" && config.teamId.trim()
-            ? config.teamId.trim()
-            : undefined,
-        channelMappings: typeof config.channelMappings === "string" &&
-            config.channelMappings.trim()
-            ? config.channelMappings.trim()
-            : undefined,
-        authMode: resolveAuthMode(config),
-        model: typeof config.model === "string" && config.model.trim()
-            ? config.model.trim()
-            : undefined,
+        channelMappings: trimmedString(config.channelMappings),
+        model: trimmedString(config.model),
     };
 }
-export function formatMissingCredentials(missing, authMode) {
-    const lines = [
-        "Slack agent setup is incomplete. Configure the following in plugin config, workspace settings, or environment variables:",
-    ];
+export function resolveSlackSigningSecret() {
+    return lookupSecret({ envKeys: ["SLACK_SIGNING_SECRET"] });
+}
+export function formatMissingCredentials(missing) {
+    const lines = ["Slack agent setup is incomplete. Set these workspace variables:"];
     if (missing.includes("botToken")) {
-        lines.push("- `botToken` / `SLACK_BOT_TOKEN` — Slack bot OAuth token (`xoxb-…`)");
+        lines.push("- `SLACK_BOT_TOKEN` — Slack bot OAuth token (`xoxb-…`)");
     }
     if (missing.includes("teamId")) {
-        lines.push("- `teamId` / `SLACK_TEAM_ID` — workspace team id (`T…`)");
-    }
-    if (missing.includes("openaiApiKey")) {
-        if (authMode === "credits") {
-            lines.push("- OpenAI API key is required in BYOK mode — add `OPENAI_API_KEY` under workspace settings, or switch `authMode` to `credits` on cloud");
-        }
-        else {
-            lines.push("- `OPENAI_API_KEY` — OpenAI API key for the agent loop (BYOK mode), or switch `authMode` to `credits` on cloud");
-        }
+        lines.push("- `SLACK_TEAM_ID` — workspace team id (`T…`)");
     }
     return lines.join("\n");
 }
-export async function resolveSlackCredentials(config, storage, options) {
-    const authMode = config.authMode ?? resolveAuthMode({});
-    const useCredits = shouldUseCreditsAuth({ authMode });
-    const requireOpenAi = options?.requireOpenAi ?? !useCredits;
-    const variables = (await storage.getVariables().catch(() => ({})));
-    const resolve = (configKey, envKey) => {
-        const fromConfig = config[configKey];
-        if (typeof fromConfig === "string" && fromConfig.trim()) {
-            return fromConfig.trim();
-        }
-        if (process.env[envKey]?.trim())
-            return process.env[envKey].trim();
-        return variableValue(variables, envKey)?.trim();
-    };
-    const signingSecret = (typeof config.signingSecret === "string" && config.signingSecret.trim()) ||
-        process.env.SLACK_SIGNING_SECRET?.trim() ||
-        variableValue(variables, "SLACK_SIGNING_SECRET") ||
-        "";
-    const botToken = resolve("botToken", "SLACK_BOT_TOKEN");
-    const teamId = resolve("teamId", "SLACK_TEAM_ID");
-    const openaiApiKey = process.env.OPENAI_API_KEY?.trim() ||
-        variableValue(variables, "OPENAI_API_KEY");
-    const model = resolve("model", "OPENAI_MODEL") ?? "openai/gpt-4o-mini";
+export function resolveSlackCredentials(config) {
+    const signingSecret = lookupSecret({ envKeys: ["SLACK_SIGNING_SECRET"] }) ?? "";
+    const botToken = lookupSecret({ envKeys: ["SLACK_BOT_TOKEN"] });
+    const teamId = lookupSecret({ envKeys: ["SLACK_TEAM_ID"] });
+    const model = trimmedString(config.model) ?? "openai/gpt-4o-mini";
     const missing = [];
     if (!botToken)
         missing.push("botToken");
     if (!teamId)
         missing.push("teamId");
-    if (requireOpenAi && !openaiApiKey)
-        missing.push("openaiApiKey");
-    if (missing.length > 0) {
+    if (missing.length > 0)
         return { ok: false, missing };
-    }
     return {
         ok: true,
         credentials: {
             signingSecret,
             botToken: botToken,
             teamId: teamId,
-            authMode,
-            openaiApiKey: openaiApiKey || undefined,
             model,
         },
     };

package/dist/index.js

@@ -1,451 +1,34 @@
-import { randomUUID } from "node:crypto";
-import { agentOutput, definePlugin, decodeWebhookRawBody, getWebhookHeader, shouldHandleInvoke, webhookHttpResponse, } from "@meetopenbot/plugin-sdk";
-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";
-}
-const seenSlackEvents = new Map();
-const SLACK_EVENT_DEDUP_MS = 5 * 60 * 1000;
-function purgeStaleSlackEvents(now) {
-    for (const [id, at] of seenSlackEvents) {
-        if (now - at > SLACK_EVENT_DEDUP_MS)
-            seenSlackEvents.delete(id);
-    }
-}
-function markSlackEventSeen(dedupKey) {
-    const now = Date.now();
-    purgeStaleSlackEvents(now);
-    if (seenSlackEvents.has(dedupKey))
-        return true;
-    seenSlackEvents.set(dedupKey, now);
-    return false;
-}
-function slackEventDedupKey(payload, slackEvent) {
-    if (payload.event_id)
-        return payload.event_id;
-    return `${slackEvent.channel}:${slackEvent.ts}`;
-}
-/** MVP: channel mentions via app_mention; DMs via message.im only. */
-function shouldProcessSlackEvent(slackEvent) {
-    if (slackEvent.bot_id)
-        return false;
-    if (slackEvent.subtype)
-        return false;
-    if (slackEvent.type === "app_mention")
-        return true;
-    if (slackEvent.type === "message" && slackEvent.channel_type === "im") {
-        return true;
-    }
-    return false;
-}
-function normalizeSlackText(text) {
-    return text.replace(/<@[^>]+>/g, "").replace(/\s+/g, " ").trim();
-}
-function getSlackThreadMeta(meta) {
-    const slack = meta?.slack;
-    if (!slack || typeof slack !== "object")
-        return undefined;
-    return slack;
-}
-async function* bridgeSystemAgentRun(args) {
-    const runId = `slack_${randomUUID()}`;
-    const slackMeta = getSlackThreadMeta(args.meta);
-    const eventQueue = [];
-    let resolveNext = null;
-    let isFinished = false;
-    const runPromise = args.host
-        .runAgent({
-        runId,
-        agentId: ROUTING_AGENT_ID,
-        publicBaseUrl: args.publicBaseUrl,
-        // Runtime's webhook ingress handles persistence.
-        persistEvents: false,
-        event: {
-            type: "agent:invoke",
-            data: {
-                agentId: ROUTING_AGENT_ID,
-                role: "user",
-                content: args.userMessage,
-            },
-            meta: {
-                channelId: args.channelId,
-                threadId: args.threadId,
-                source: "slack",
-                slack: slackMeta,
-                userName: SLACK_USER_DISPLAY_NAME,
-                ...(typeof args.meta?.userId === "string"
-                    ? { userId: args.meta.userId }
-                    : {}),
-            },
-        },
-        onEvent: async (outEvent) => {
-            if (outEvent.type === "agent:output" &&
-                !outEvent.meta?.parentToolCallId) {
-                const output = outEvent;
-                eventQueue.push({
-                    ...output,
-                    meta: {
-                        ...output.meta,
-                        agentId: ROUTING_AGENT_ID,
-                        threadId: args.threadId,
-                        source: "slack",
-                        slack: slackMeta,
-                    },
-                });
-            }
-            if (resolveNext) {
-                resolveNext();
-                resolveNext = null;
-            }
-        },
-    })
-        .catch((error) => {
-        const message = error instanceof Error ? error.message : String(error);
-        eventQueue.push({
-            type: "agent:output",
-            data: { content: `Slack agent error: ${message}` },
-            meta: {
-                agentId: ROUTING_AGENT_ID,
-                threadId: args.threadId,
-                source: "slack",
-                slack: slackMeta,
-            },
-        });
-    })
-        .finally(() => {
-        isFinished = true;
-        if (resolveNext) {
-            resolveNext();
-            resolveNext = null;
-        }
-    });
-    while (!isFinished || eventQueue.length > 0) {
-        if (eventQueue.length === 0) {
-            await new Promise((resolve) => {
-                resolveNext = resolve;
-            });
-        }
-        while (eventQueue.length > 0) {
-            yield eventQueue.shift();
-        }
-    }
-    await runPromise;
-}
-const modelField = await resolveModelConfigField();
-const slackPluginConfigSchema = {
-    type: "object",
-    properties: {
-        ...(isCloudMode()
-            ? {
-                authMode: {
-                    type: "string",
-                    description: "Outbound — Credits uses your workspace credit balance via OpenBot. BYOK uses `OPENAI_API_KEY` from workspace settings.",
-                    enum: ["credits", "byok"],
-                    default: "credits",
-                },
-            }
-            : {}),
-        model: {
-            ...modelField,
-            description: "Outbound — OpenAI model for direct Slack agent invocations",
-        },
-        botToken: {
-            type: "string",
-            description: "Outbound — Slack bot token (OAuth & Permissions → Bot User OAuth Token)",
-            format: "password",
-        },
-        teamId: {
-            type: "string",
-            description: "Outbound — Slack workspace team id (starts with T)",
-        },
-        signingSecret: {
-            type: "string",
-            description: "Inbound — Slack app signing secret (Basic Information → App Credentials)",
-            format: "password",
-        },
-        channelMappings: {
-            type: "string",
-            description: "Inbound — webhook routing. Comma-separated slackChannelId:openbotChannelId pairs (e.g. C01234567:engineering,C89ABCDEF:support). Unmapped Slack channels use general.",
-        },
-    },
-    required: ["signingSecret"],
-};
-export default definePlugin({
+import { definePlugin, } from "@meetopenbot/plugin-sdk";
+import { pluginConfigSchema, readSlackConfig } from "./config.js";
+import { handleSlackInvoke, handleSlackOutbound } from "./invoke.js";
+import { handleSlackWebhook } from "./webhook.js";
+export const plugin = definePlugin({
     name: "Slack",
     description: "Slack Events API ingress, local agent runtime, and system delegation for webhooks",
-    configSchema: slackPluginConfigSchema,
+    configSchema: pluginConfigSchema,
     factory: (pluginContext) => (builder) => {
-        const { agentId, config, storage } = pluginContext;
+        const { agentId, config, host, publicBaseUrl } = pluginContext;
         const slackConfig = readSlackConfig(config);
-        const host = pluginContext.host;
-        const publicBaseUrl = pluginContext.publicBaseUrl ?? "";
         builder.on("action:webhook", async function* (event, ctx) {
-            const webhook = event;
-            if (webhook.data.provider !== "slack")
-                return;
-            const auth = await resolveSlackCredentials(slackConfig, storage);
-            const signingSecret = auth.ok
-                ? auth.credentials.signingSecret
-                : String(config.signingSecret ?? "").trim();
-            const rawBody = decodeWebhookRawBody(webhook);
-            let payload;
-            try {
-                payload = JSON.parse(rawBody.toString("utf8"));
-            }
-            catch {
-                yield webhookHttpResponse({
-                    status: 400,
-                    body: { error: "invalid json" },
-                });
-                return;
-            }
-            if (payload.type === "url_verification") {
-                yield webhookHttpResponse({
-                    status: 200,
-                    body: { challenge: payload.challenge },
-                });
-                return;
-            }
-            const timestamp = getWebhookHeader(webhook, "x-slack-request-timestamp");
-            const signature = getWebhookHeader(webhook, "x-slack-signature");
-            if (!verifySlackSignature(signingSecret, rawBody, timestamp, signature)) {
-                yield webhookHttpResponse({
-                    status: 401,
-                    body: { error: "invalid signature" },
-                });
-                return;
-            }
-            const slackEvent = payload.type === "event_callback" ? payload.event : undefined;
-            if (!slackEvent) {
-                yield webhookHttpResponse({ status: 200, body: {} });
-                return;
-            }
-            if (!shouldProcessSlackEvent(slackEvent)) {
-                yield webhookHttpResponse({ status: 200, body: {} });
-                return;
-            }
-            const dedupKey = slackEventDedupKey(payload, slackEvent);
-            if (markSlackEventSeen(dedupKey)) {
-                yield webhookHttpResponse({ status: 200, body: {} });
-                return;
-            }
-            const text = normalizeSlackText(slackEvent.text ?? "");
-            if (!text) {
-                yield webhookHttpResponse({ status: 200, body: {} });
-                return;
-            }
-            const threadId = slackEvent.thread_ts ?? slackEvent.ts;
-            if (!threadId) {
-                yield webhookHttpResponse({ status: 200, body: {} });
-                return;
-            }
-            ctx.state.threadId = threadId;
-            const slackMeta = {
-                teamId: payload.team_id,
-                channel: slackEvent.channel,
-                user: slackEvent.user,
-                ts: slackEvent.ts,
-                threadTs: slackEvent.thread_ts,
-            };
-            const openBotChannelId = slackEvent.channel
-                ? resolveOpenBotChannelId(slackEvent.channel, slackConfig)
-                : DEFAULT_OPENBOT_CHANNEL_ID;
-            ctx.state.channelId = openBotChannelId;
-            yield webhookHttpResponse({ status: 200, body: {} });
-            yield {
-                type: "agent:invoke",
-                data: {
-                    agentId: ROUTING_AGENT_ID,
-                    role: "user",
-                    content: text,
-                },
-                meta: {
-                    channelId: openBotChannelId,
-                    threadId,
-                    source: "slack",
-                    slack: slackMeta,
-                    userName: SLACK_USER_DISPLAY_NAME,
-                    ...(slackEvent.user ? { userId: slackEvent.user } : {}),
-                },
-            };
+            yield* handleSlackWebhook({
+                event: event,
+                ctx,
+                config: slackConfig,
+            });
         });
         builder.on("agent:invoke", async function* (event, ctx) {
-            const fromWebhook = isSlackWebhookIngress(event.meta);
-            if (fromWebhook) {
-                if (!shouldHandleInvoke(event, ROUTING_AGENT_ID))
-                    return;
-            }
-            else {
-                if (!shouldHandleInvoke(event, agentId))
-                    return;
-            }
-            if (event.meta?.threadId) {
-                ctx.state.threadId = event.meta.threadId;
-            }
-            const threadId = event.meta?.threadId ?? ctx.state.threadId;
-            const userMessage = (event.data.content ?? "").trim();
-            if (!userMessage || !threadId)
-                return;
-            if (fromWebhook) {
-                const auth = await resolveSlackCredentials(slackConfig, storage, {
-                    requireOpenAi: false,
-                });
-                if (!auth.ok) {
-                    yield {
-                        type: "agent:output",
-                        data: {
-                            content: formatMissingCredentials(auth.missing, slackConfig.authMode),
-                        },
-                        meta: {
-                            agentId: ROUTING_AGENT_ID,
-                            threadId,
-                            source: "slack",
-                            slack: getSlackThreadMeta(event.meta),
-                        },
-                    };
-                    return;
-                }
-                if (!host?.runAgent) {
-                    yield {
-                        type: "agent:output",
-                        data: {
-                            content: "Slack plugin requires host.runAgent to delegate to the system agent.",
-                        },
-                        meta: {
-                            agentId: ROUTING_AGENT_ID,
-                            threadId,
-                            source: "slack",
-                            slack: getSlackThreadMeta(event.meta),
-                        },
-                    };
-                    return;
-                }
-                const slackMeta = getSlackThreadMeta(event.meta);
-                const channelId = slackMeta?.channel
-                    ? resolveOpenBotChannelId(slackMeta.channel, slackConfig)
-                    : 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: prompt,
-                        meta: event.meta,
-                        publicBaseUrl,
-                    });
-                }
-                catch (error) {
-                    const message = error instanceof Error ? error.message : String(error);
-                    yield {
-                        type: "agent:output",
-                        data: { content: `Slack agent error: ${message}` },
-                        meta: {
-                            agentId: ROUTING_AGENT_ID,
-                            threadId,
-                            source: "slack",
-                            slack: getSlackThreadMeta(event.meta),
-                        },
-                    };
-                }
-                return;
-            }
-            const auth = await resolveSlackCredentials(slackConfig, storage);
-            if (!auth.ok) {
-                yield agentOutput({
-                    agentId,
-                    content: formatMissingCredentials(auth.missing, slackConfig.authMode),
-                    threadId,
-                    meta: event.meta,
-                });
-                return;
-            }
-            if (auth.credentials.authMode === "credits" &&
-                !resolveCreditsAuthConfig()) {
-                yield agentOutput({
-                    agentId,
-                    content: CREDITS_NOT_CONFIGURED_MESSAGE,
-                    threadId,
-                    meta: event.meta,
-                });
-                return;
-            }
-            try {
-                const reply = await runSlackAgent({
-                    prompt: userMessage,
-                    authMode: auth.credentials.authMode,
-                    openaiApiKey: auth.credentials.openaiApiKey,
-                    botToken: auth.credentials.botToken,
-                    teamId: auth.credentials.teamId,
-                    model: auth.credentials.model,
-                });
-                yield agentOutput({
-                    agentId,
-                    content: reply,
-                    threadId,
-                    meta: event.meta,
-                });
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                const creditsMessage = auth.credentials.authMode === "credits"
-                    ? creditsErrorMessage(message)
-                    : undefined;
-                yield agentOutput({
-                    agentId,
-                    content: creditsMessage ?? `Slack agent error: ${message}`,
-                    threadId,
-                    meta: event.meta,
-                });
-            }
+            yield* handleSlackInvoke({
+                event,
+                ctx,
+                agentId,
+                config: slackConfig,
+                host,
+                publicBaseUrl: publicBaseUrl ?? "",
+            });
         });
         builder.on("agent:output", async function* (event) {
-            if (event.meta?.source !== "slack")
-                return;
-            if (event.meta?.agentId !== ROUTING_AGENT_ID)
-                return;
-            const slack = getSlackThreadMeta(event.meta);
-            if (!slack?.channel)
-                return;
-            const auth = await resolveSlackCredentials(slackConfig, storage);
-            if (!auth.ok)
-                return;
-            try {
-                await postSlackMessage({
-                    token: auth.credentials.botToken,
-                    channel: slack.channel,
-                    text: event.data.content,
-                    threadTs: slack.threadTs ?? slack.ts,
-                });
-            }
-            catch {
-                // Avoid failing the bus run if Slack delivery fails.
-            }
+            yield* handleSlackOutbound({ event, config: slackConfig });
         });
     },
 });
+export default plugin;

package/dist/invoke.js

@@ -0,0 +1,246 @@
+import { randomUUID } from "node:crypto";
+import { agentOutput, creditsErrorMessage, hasLlmAuth, llmAuthNotConfiguredMessage, shouldHandleInvoke, } from "@meetopenbot/plugin-sdk";
+import { runSlackAgent } from "./agent.js";
+import { formatMissingCredentials, resolveOpenBotChannelId, resolveSlackCredentials, ROUTING_AGENT_ID, SLACK_USER_DISPLAY_NAME, } from "./config.js";
+import { buildPromptWithSlackContext } from "./context.js";
+import { postSlackMessage } from "./post.js";
+import { getSlackThreadMeta, isSlackWebhookIngress } from "./webhook.js";
+async function* bridgeSystemAgentRun(args) {
+    const runId = `slack_${randomUUID()}`;
+    const slackMeta = getSlackThreadMeta(args.meta);
+    const eventQueue = [];
+    let resolveNext = null;
+    let isFinished = false;
+    const runPromise = args.host
+        .runAgent({
+        runId,
+        agentId: ROUTING_AGENT_ID,
+        publicBaseUrl: args.publicBaseUrl,
+        persistEvents: false,
+        event: {
+            type: "agent:invoke",
+            data: {
+                agentId: ROUTING_AGENT_ID,
+                role: "user",
+                content: args.userMessage,
+            },
+            meta: {
+                channelId: args.channelId,
+                threadId: args.threadId,
+                source: "slack",
+                slack: slackMeta,
+                userName: SLACK_USER_DISPLAY_NAME,
+                ...(typeof args.meta?.userId === "string" ? { userId: args.meta.userId } : {}),
+            },
+        },
+        onEvent: async (outEvent) => {
+            if (outEvent.type === "agent:output" && !outEvent.meta?.parentToolCallId) {
+                const output = outEvent;
+                eventQueue.push({
+                    ...output,
+                    meta: {
+                        ...output.meta,
+                        agentId: ROUTING_AGENT_ID,
+                        threadId: args.threadId,
+                        source: "slack",
+                        slack: slackMeta,
+                    },
+                });
+            }
+            if (resolveNext) {
+                resolveNext();
+                resolveNext = null;
+            }
+        },
+    })
+        .catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        eventQueue.push({
+            type: "agent:output",
+            data: { content: `Slack agent error: ${message}` },
+            meta: {
+                agentId: ROUTING_AGENT_ID,
+                threadId: args.threadId,
+                source: "slack",
+                slack: slackMeta,
+            },
+        });
+    })
+        .finally(() => {
+        isFinished = true;
+        if (resolveNext) {
+            resolveNext();
+            resolveNext = null;
+        }
+    });
+    while (!isFinished || eventQueue.length > 0) {
+        if (eventQueue.length === 0) {
+            await new Promise((resolve) => {
+                resolveNext = resolve;
+            });
+        }
+        while (eventQueue.length > 0) {
+            yield eventQueue.shift();
+        }
+    }
+    await runPromise;
+}
+export async function* handleSlackInvoke(args) {
+    const fromWebhook = isSlackWebhookIngress(args.event.meta);
+    if (fromWebhook) {
+        if (!shouldHandleInvoke(args.event, ROUTING_AGENT_ID))
+            return;
+    }
+    else if (!shouldHandleInvoke(args.event, args.agentId)) {
+        return;
+    }
+    if (args.event.meta?.threadId) {
+        args.ctx.state.threadId = args.event.meta.threadId;
+    }
+    const threadId = args.event.meta?.threadId ?? args.ctx.state.threadId;
+    const userMessage = (args.event.data.content ?? "").trim();
+    if (!userMessage || !threadId)
+        return;
+    if (fromWebhook) {
+        const auth = resolveSlackCredentials(args.config);
+        if (!auth.ok) {
+            yield {
+                type: "agent:output",
+                data: { content: formatMissingCredentials(auth.missing) },
+                meta: {
+                    agentId: ROUTING_AGENT_ID,
+                    threadId,
+                    source: "slack",
+                    slack: getSlackThreadMeta(args.event.meta),
+                },
+            };
+            return;
+        }
+        if (!args.host?.runAgent) {
+            yield {
+                type: "agent:output",
+                data: {
+                    content: "Slack plugin requires host.runAgent to delegate to the system agent.",
+                },
+                meta: {
+                    agentId: ROUTING_AGENT_ID,
+                    threadId,
+                    source: "slack",
+                    slack: getSlackThreadMeta(args.event.meta),
+                },
+            };
+            return;
+        }
+        const slackMeta = getSlackThreadMeta(args.event.meta);
+        const channelId = slackMeta?.channel
+            ? resolveOpenBotChannelId(slackMeta.channel, args.config)
+            : args.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: args.host,
+                channelId,
+                threadId,
+                userMessage: prompt,
+                meta: args.event.meta,
+                publicBaseUrl: args.publicBaseUrl,
+            });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            yield {
+                type: "agent:output",
+                data: { content: `Slack agent error: ${message}` },
+                meta: {
+                    agentId: ROUTING_AGENT_ID,
+                    threadId,
+                    source: "slack",
+                    slack: getSlackThreadMeta(args.event.meta),
+                },
+            };
+        }
+        return;
+    }
+    const auth = resolveSlackCredentials(args.config);
+    if (!auth.ok) {
+        yield agentOutput({
+            agentId: args.agentId,
+            content: formatMissingCredentials(auth.missing),
+            threadId,
+            meta: args.event.meta,
+        });
+        return;
+    }
+    if (!hasLlmAuth("openai")) {
+        yield agentOutput({
+            agentId: args.agentId,
+            content: llmAuthNotConfiguredMessage(),
+            threadId,
+            meta: args.event.meta,
+        });
+        return;
+    }
+    try {
+        const reply = await runSlackAgent({
+            prompt: userMessage,
+            botToken: auth.credentials.botToken,
+            teamId: auth.credentials.teamId,
+            model: auth.credentials.model,
+        });
+        yield agentOutput({
+            agentId: args.agentId,
+            content: reply,
+            threadId,
+            meta: args.event.meta,
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        yield agentOutput({
+            agentId: args.agentId,
+            content: creditsErrorMessage(message, { agentName: "Slack" }) ??
+                `Slack agent error: ${message}`,
+            threadId,
+            meta: args.event.meta,
+        });
+    }
+}
+export async function* handleSlackOutbound(args) {
+    if (args.event.meta?.source !== "slack")
+        return;
+    if (args.event.meta?.agentId !== ROUTING_AGENT_ID)
+        return;
+    const slack = getSlackThreadMeta(args.event.meta);
+    if (!slack?.channel)
+        return;
+    const auth = resolveSlackCredentials(args.config);
+    if (!auth.ok)
+        return;
+    try {
+        await postSlackMessage({
+            token: auth.credentials.botToken,
+            channel: slack.channel,
+            text: args.event.data.content,
+            threadTs: slack.threadTs ?? slack.ts,
+        });
+    }
+    catch {
+        // Avoid failing the bus run if Slack delivery fails.
+    }
+}

package/dist/webhook.js

@@ -0,0 +1,112 @@
+import { decodeWebhookRawBody, getWebhookHeader, webhookHttpResponse, } from "@meetopenbot/plugin-sdk";
+import { DEFAULT_OPENBOT_CHANNEL_ID, ROUTING_AGENT_ID, SLACK_USER_DISPLAY_NAME, resolveOpenBotChannelId, resolveSlackSigningSecret, } from "./config.js";
+import { verifySlackSignature } from "./verify.js";
+const seenSlackEvents = new Map();
+const SLACK_EVENT_DEDUP_MS = 5 * 60 * 1000;
+function purgeStaleSlackEvents(now) {
+    for (const [id, at] of seenSlackEvents) {
+        if (now - at > SLACK_EVENT_DEDUP_MS)
+            seenSlackEvents.delete(id);
+    }
+}
+function markSlackEventSeen(dedupKey) {
+    const now = Date.now();
+    purgeStaleSlackEvents(now);
+    if (seenSlackEvents.has(dedupKey))
+        return true;
+    seenSlackEvents.set(dedupKey, now);
+    return false;
+}
+function slackEventDedupKey(payload, slackEvent) {
+    if (payload.event_id)
+        return payload.event_id;
+    return `${slackEvent.channel}:${slackEvent.ts}`;
+}
+function shouldProcessSlackEvent(slackEvent) {
+    if (slackEvent.bot_id || slackEvent.subtype)
+        return false;
+    if (slackEvent.type === "app_mention")
+        return true;
+    return slackEvent.type === "message" && slackEvent.channel_type === "im";
+}
+function normalizeSlackText(text) {
+    return text.replace(/<@[^>]+>/g, "").replace(/\s+/g, " ").trim();
+}
+export function isSlackWebhookIngress(meta) {
+    return meta?.source === "slack";
+}
+export function getSlackThreadMeta(meta) {
+    const slack = meta?.slack;
+    if (!slack || typeof slack !== "object")
+        return undefined;
+    return slack;
+}
+export async function* handleSlackWebhook(args) {
+    if (args.event.data.provider !== "slack")
+        return;
+    const signingSecret = resolveSlackSigningSecret() ?? "";
+    const rawBody = decodeWebhookRawBody(args.event);
+    let payload;
+    try {
+        payload = JSON.parse(rawBody.toString("utf8"));
+    }
+    catch {
+        yield webhookHttpResponse({ status: 400, body: { error: "invalid json" } });
+        return;
+    }
+    if (payload.type === "url_verification") {
+        yield webhookHttpResponse({ status: 200, body: { challenge: payload.challenge } });
+        return;
+    }
+    const timestamp = getWebhookHeader(args.event, "x-slack-request-timestamp");
+    const signature = getWebhookHeader(args.event, "x-slack-signature");
+    if (!verifySlackSignature(signingSecret, rawBody, timestamp, signature)) {
+        yield webhookHttpResponse({ status: 401, body: { error: "invalid signature" } });
+        return;
+    }
+    const slackEvent = payload.type === "event_callback" ? payload.event : undefined;
+    if (!slackEvent || !shouldProcessSlackEvent(slackEvent)) {
+        yield webhookHttpResponse({ status: 200, body: {} });
+        return;
+    }
+    const dedupKey = slackEventDedupKey(payload, slackEvent);
+    if (markSlackEventSeen(dedupKey)) {
+        yield webhookHttpResponse({ status: 200, body: {} });
+        return;
+    }
+    const text = normalizeSlackText(slackEvent.text ?? "");
+    const threadId = slackEvent.thread_ts ?? slackEvent.ts;
+    if (!text || !threadId) {
+        yield webhookHttpResponse({ status: 200, body: {} });
+        return;
+    }
+    args.ctx.state.threadId = threadId;
+    const slackMeta = {
+        teamId: payload.team_id,
+        channel: slackEvent.channel,
+        user: slackEvent.user,
+        ts: slackEvent.ts,
+        threadTs: slackEvent.thread_ts,
+    };
+    const openBotChannelId = slackEvent.channel
+        ? resolveOpenBotChannelId(slackEvent.channel, args.config)
+        : DEFAULT_OPENBOT_CHANNEL_ID;
+    args.ctx.state.channelId = openBotChannelId;
+    yield webhookHttpResponse({ status: 200, body: {} });
+    yield {
+        type: "agent:invoke",
+        data: {
+            agentId: ROUTING_AGENT_ID,
+            role: "user",
+            content: text,
+        },
+        meta: {
+            channelId: openBotChannelId,
+            threadId,
+            source: "slack",
+            slack: slackMeta,
+            userName: SLACK_USER_DISPLAY_NAME,
+            ...(slackEvent.user ? { userId: slackEvent.user } : {}),
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meetopenbot/slack",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "Slack Events API ingress, simple agent replies, and thread delivery for OpenBot",
   "type": "module",
   "main": "./dist/index.js",
@@ -19,10 +19,7 @@
     "dist"
   ],
   "dependencies": {
-    "@ai-sdk/mcp": "^2.0.14",
-    "@ai-sdk/openai": "^4.0.15",
-    "ai": "^7.0.29",
-    "@meetopenbot/plugin-sdk": "^0.2.0"
+    "@meetopenbot/plugin-sdk": "^0.3.0"
   },
   "devDependencies": {
     "@types/node": "^20.10.1",

package/dist/cloud-mode.js

@@ -1,10 +0,0 @@
-/** True when this runtime is a platform-managed cloud deployment. */
-export const isCloudMode = () => process.env.OPENBOT_CLOUD_MODE === "1";
-/** Default auth mode: Credits on cloud, BYOK locally. */
-export const defaultAuthMode = () => isCloudMode() ? "credits" : "byok";
-export function resolveAuthMode(config) {
-    if (config.authMode === "byok" || config.authMode === "credits") {
-        return config.authMode;
-    }
-    return defaultAuthMode();
-}

package/dist/credits-auth.js

@@ -1,53 +0,0 @@
-import { isCloudMode } from "./cloud-mode.js";
-export const INTEGRATIONS_TOKEN_HEADER = "x-openbot-integrations-token";
-export const CREDITS_API_KEY_PLACEHOLDER = "openbot-credits";
-/** Cloud host injects these when routing LLM calls through OpenBot Credits. */
-export function resolveCreditsAuthConfig() {
-    const baseUrl = process.env.OPENBOT_INTEGRATIONS_BASE_URL?.trim();
-    const token = process.env.OPENBOT_INTEGRATIONS_TOKEN?.trim();
-    if (!baseUrl || !token)
-        return undefined;
-    return { baseUrl: baseUrl.replace(/\/$/, ""), token };
-}
-export function creditsProviderBaseUrl(config) {
-    return `${config.baseUrl}/openai/v1`;
-}
-export function shouldUseCreditsAuth(options) {
-    if (options?.authMode === "byok")
-        return false;
-    if (options?.authMode === "credits")
-        return true;
-    return isCloudMode() && resolveCreditsAuthConfig() !== undefined;
-}
-export function isCreditsErrorMessage(message) {
-    const lower = message.toLowerCase();
-    return (lower.includes("insufficient_credits") ||
-        lower.includes("insufficient credits") ||
-        lower.includes("402"));
-}
-export function isAuthErrorMessage(message) {
-    const lower = message.toLowerCase();
-    return (lower.includes("api key") ||
-        lower.includes("401") ||
-        lower.includes("unauthorized") ||
-        lower.includes("authentication"));
-}
-export function isIntegrationsProviderError(message) {
-    const lower = message.toLowerCase();
-    return (lower.includes("provider api key not configured") ||
-        (lower.includes("503") && lower.includes("provider")));
-}
-export const CREDITS_NOT_CONFIGURED_MESSAGE = "OpenBot Credits is not configured on this runtime. The cloud host must set OPENBOT_INTEGRATIONS_BASE_URL and OPENBOT_INTEGRATIONS_TOKEN (try redeploying the workspace).";
-export const CREDITS_PROVIDER_UNAVAILABLE_MESSAGE = "OpenBot Credits could not reach OpenAI — the platform provider API key is not configured yet. Try again later or switch this agent to BYOK mode.";
-export const CREDITS_AUTH_FAILED_MESSAGE = "Slack could not authenticate via OpenBot Credits. Check your workspace credit balance in settings, or switch this agent to BYOK mode.";
-export function creditsErrorMessage(message) {
-    if (isIntegrationsProviderError(message)) {
-        return CREDITS_PROVIDER_UNAVAILABLE_MESSAGE;
-    }
-    if (isCreditsErrorMessage(message)) {
-        return "Insufficient workspace credits. Add credits in workspace settings or switch this agent to BYOK mode.";
-    }
-    if (isAuthErrorMessage(message))
-        return CREDITS_AUTH_FAILED_MESSAGE;
-    return undefined;
-}

package/dist/model-registry.js

@@ -1,40 +0,0 @@
-const REGISTRY_URL = "https://raw.githubusercontent.com/meetopenbot/openbot-registry/main/registry.json";
-const OPENAI_PROVIDER = "openai";
-const freeInputModelField = () => ({
-    type: "string",
-    override: true,
-    description: "OpenAI model in provider/model-id format (e.g. openai/gpt-4o-mini).",
-    default: "openai/gpt-4o-mini",
-});
-/** Registry-backed model field for plugin configSchema (`enum` + labeled `options`). */
-export async function resolveModelConfigField() {
-    try {
-        const res = await fetch(REGISTRY_URL, {
-            headers: { Accept: "application/json" },
-            signal: AbortSignal.timeout(15_000),
-        });
-        if (!res.ok)
-            return freeInputModelField();
-        const registry = (await res.json());
-        const provider = registry.providers?.[OPENAI_PROVIDER];
-        const models = provider?.models ?? [];
-        if (models.length === 0)
-            return freeInputModelField();
-        const defaultModel = models.find((model) => model.id === "gpt-4o-mini")?.id ?? models[0].id;
-        return {
-            type: "string",
-            override: true,
-            description: "OpenAI model from the OpenBot registry.",
-            default: `${OPENAI_PROVIDER}/${defaultModel}`,
-            enum: models.map((model) => `${OPENAI_PROVIDER}/${model.id}`),
-            options: models.map((model) => ({
-                label: `${provider?.label ?? "OpenAI"} — ${model.label}`,
-                value: `${OPENAI_PROVIDER}/${model.id}`,
-                description: model.description,
-            })),
-        };
-    }
-    catch {
-        return freeInputModelField();
-    }
-}

package/dist/model.js

@@ -1,24 +0,0 @@
-import { createOpenAI } from "@ai-sdk/openai";
-import { CREDITS_API_KEY_PLACEHOLDER, INTEGRATIONS_TOKEN_HEADER, creditsProviderBaseUrl, resolveCreditsAuthConfig, shouldUseCreditsAuth, } from "./credits-auth.js";
-function normalizeOpenAiModelId(model) {
-    return model.includes("/") ? model.split("/").slice(1).join("/") : model;
-}
-export function resolveOpenAiModel(model, options) {
-    const modelId = normalizeOpenAiModelId(model);
-    const useCredits = shouldUseCreditsAuth(options);
-    if (useCredits) {
-        const config = resolveCreditsAuthConfig();
-        if (!config) {
-            throw new Error("OpenBot Credits is not configured. The cloud host must set OPENBOT_INTEGRATIONS_BASE_URL and OPENBOT_INTEGRATIONS_TOKEN.");
-        }
-        const baseURL = creditsProviderBaseUrl(config);
-        const headers = { [INTEGRATIONS_TOKEN_HEADER]: config.token };
-        const apiKey = config.token || CREDITS_API_KEY_PLACEHOLDER;
-        return createOpenAI({ baseURL, apiKey, headers })(modelId);
-    }
-    const apiKey = options?.openaiApiKey?.trim();
-    if (!apiKey) {
-        throw new Error("OpenAI API key is required in BYOK mode. Add `OPENAI_API_KEY` under workspace settings or switch `authMode` to `credits` on cloud.");
-    }
-    return createOpenAI({ apiKey })(modelId);
-}

package/dist/slack-agent.js

@@ -1,30 +0,0 @@
-import { generateText, stepCountIs } from "ai";
-import { resolveOpenAiModel } from "./model.js";
-import { createSlackMcpClient } from "./slack-mcp.js";
-const SYSTEM_PROMPT = `You are the OpenBot Slack specialist agent.
-Use Slack MCP tools to post messages, list channels, read history, and perform other workspace actions when needed.
-Summarize results clearly in plain text for the user. Be concise and friendly.`;
-export async function runSlackAgent(args) {
-    const model = resolveOpenAiModel(args.model ?? "openai/gpt-4o-mini", {
-        authMode: args.authMode,
-        openaiApiKey: args.openaiApiKey,
-    });
-    const mcpClient = await createSlackMcpClient({
-        botToken: args.botToken,
-        teamId: args.teamId,
-    });
-    try {
-        const tools = await mcpClient.tools();
-        const result = await generateText({
-            model,
-            system: SYSTEM_PROMPT,
-            prompt: args.prompt,
-            tools,
-            stopWhen: stepCountIs(10),
-        });
-        return result.text.trim() || "Done.";
-    }
-    finally {
-        await mcpClient.close();
-    }
-}

package/dist/slack-mcp.js

@@ -1,15 +0,0 @@
-import { createMCPClient } from "@ai-sdk/mcp";
-import { Experimental_StdioMCPTransport } from "@ai-sdk/mcp/mcp-stdio";
-export async function createSlackMcpClient(args) {
-    return createMCPClient({
-        transport: new Experimental_StdioMCPTransport({
-            command: "npx",
-            args: ["-y", "@modelcontextprotocol/server-slack"],
-            env: {
-                ...process.env,
-                SLACK_BOT_TOKEN: args.botToken,
-                SLACK_TEAM_ID: args.teamId,
-            },
-        }),
-    });
-}