@meetopenbot/slack 0.0.1

package/README.md

@@ -0,0 +1,64 @@
+# @meetopenbot/slack
+
+Slack specialist agent for OpenBot: Events API ingress, simple LLM replies, and thread delivery.
+
+## Features (MVP)
+
+- **Ingress** — verify Slack webhooks, dedupe events, turn messages into `agent:invoke`
+- **Agent** — OpenAI + Slack MCP tools (`post_message`, `list_channels`, etc.)
+- **Egress** — post inbound-thread replies via `chat.postMessage`
+
+## Setup
+
+1. Create a Slack app with bot scopes:
+
+   - `app_mentions:read`, `chat:write`
+   - For DMs: `im:history`, `im:read`, `im:write`
+
+2. Add the plugin to `~/.openbot/agents/slack/AGENT.md`:
+
+```yaml
+plugins:
+  - id: "@meetopenbot/slack"
+    config:
+      signingSecret: your-signing-secret
+      botToken: xoxb-your-bot-token
+      teamId: T01234567
+      openaiApiKey: sk-...
+      model: gpt-4o-mini
+      channelMappings: "C01234567:engineering,C89ABCDEF:support"
+```
+
+### Channel routing (webhook ingress)
+
+When a Slack message arrives via the Events API webhook, the plugin delegates to the OpenBot **system** agent in a target channel. Set `channelMappings` as comma-separated `slackChannelId:openbotChannelId` pairs:
+
+```
+C01234567:engineering,C89ABCDEF:support,D0789ABC:slack-dms
+```
+
+- **Left side** — Slack channel id (`C…` for channels, `D…` for DMs). In Slack: right-click the channel → **View channel details** → copy the id at the bottom.
+- **Right side** — OpenBot channel id to run in (must already exist).
+
+Slack channels without a mapping route to **`uncategorized`**.
+
+This applies only to **webhook ingress delegation**, not Slack MCP tools.
+
+3. Point Slack **Event Subscriptions** request URL to:
+
+```
+https://<your-host>/api/webhooks/slack
+```
+
+4. Subscribe to **`app_mention`** for channel mentions. Add **`message.im`** only if you want DMs.
+
+   Do **not** subscribe to `message.channels` or `message.groups` — that causes duplicate replies alongside `app_mention`.
+
+## Build
+
+```bash
+pnpm install
+pnpm build
+```
+
+Restart the OpenBot runtime to load the plugin.

package/dist/config.js

@@ -0,0 +1,77 @@
+export const DEFAULT_OPENBOT_CHANNEL_ID = "uncategorized";
+/** Parse `C0123:engineering,C0456:support` into a lookup index. */
+export function buildSlackChannelMappingIndex(config) {
+    const index = new Map();
+    const raw = typeof config.channelMappings === "string"
+        ? config.channelMappings.trim()
+        : "";
+    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);
+    }
+    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 varValue(variables, key) {
+    const variable = variables[key];
+    return typeof variable === "string" ? variable : variable?.value;
+}
+export async function resolveSlackCredentials(config, storage, options) {
+    const requireOpenAi = options?.requireOpenAi ?? true;
+    const variables = await storage.getVariables();
+    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 varValue(variables, envKey)?.trim();
+    };
+    const signingSecret = (typeof config.signingSecret === "string" && config.signingSecret.trim()) ||
+        process.env.SLACK_SIGNING_SECRET?.trim() ||
+        varValue(variables, "SLACK_SIGNING_SECRET") ||
+        "";
+    const botToken = resolve("botToken", "SLACK_BOT_TOKEN");
+    const teamId = resolve("teamId", "SLACK_TEAM_ID");
+    const openaiApiKey = resolve("openaiApiKey", "OPENAI_API_KEY");
+    const model = resolve("model", "OPENAI_MODEL") ?? "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) {
+        return { ok: false, missing };
+    }
+    return {
+        ok: true,
+        credentials: {
+            signingSecret,
+            botToken: botToken,
+            teamId: teamId,
+            openaiApiKey: openaiApiKey ?? "",
+            model,
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/index.js

@@ -0,0 +1,419 @@
+import { randomUUID } from "node:crypto";
+import { agentOutput, definePlugin, decodeWebhookRawBody, getWebhookHeader, shouldHandleInvoke, webhookHttpResponse, } from "@meetopenbot/plugin-sdk";
+import { DEFAULT_OPENBOT_CHANNEL_ID, resolveOpenBotChannelId, resolveSlackCredentials, } from "./config.js";
+import { postSlackMessage } from "./slack-post.js";
+import { runSlackAgent } from "./slack-agent.js";
+import { verifySlackSignature } from "./slack-verify.js";
+const ROUTING_AGENT_ID = "system";
+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;
+}
+function formatMissingCredentials(missing) {
+    const lines = [
+        "Slack agent setup is incomplete. Configure the following in plugin config or environment variables:",
+    ];
+    if (missing.includes("botToken")) {
+        lines.push("- `botToken` / `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")) {
+        lines.push("- `openaiApiKey` / `OPENAI_API_KEY` — OpenAI API key for the agent loop");
+    }
+    return lines.join("\n");
+}
+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,
+            },
+        },
+        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 slackPluginConfigSchema = {
+    type: "object",
+    properties: {
+        signingSecret: {
+            type: "string",
+            description: "Slack app signing secret (Basic Information → App Credentials)",
+            format: "password",
+        },
+        botToken: {
+            type: "string",
+            description: "Slack bot token (OAuth & Permissions → Bot User OAuth Token)",
+            format: "password",
+        },
+        teamId: {
+            type: "string",
+            description: "Slack workspace team id (starts with T)",
+        },
+        channelMappings: {
+            type: "string",
+            description: "Webhook ingress routing. Comma-separated slackChannelId:openbotChannelId pairs (e.g. C01234567:engineering,C89ABCDEF:support). Unmapped Slack channels use uncategorized.",
+        },
+        openaiApiKey: {
+            type: "string",
+            description: "OpenAI API key for direct Slack agent invocations",
+            format: "password",
+        },
+        model: {
+            type: "string",
+            description: "OpenAI model id for direct Slack agent invocations (default: gpt-4o-mini)",
+            default: "gpt-4o-mini",
+        },
+    },
+    required: ["signingSecret"],
+};
+export default definePlugin({
+    name: "Slack",
+    description: "Slack Events API ingress, local agent runtime, and system delegation for webhooks",
+    configSchema: slackPluginConfigSchema,
+    factory: (pluginContext) => (builder) => {
+        const { agentId, config, storage } = pluginContext;
+        const slackConfig = 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,
+                },
+            };
+        });
+        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) },
+                        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;
+                try {
+                    yield* bridgeSystemAgentRun({
+                        host,
+                        channelId,
+                        threadId,
+                        userMessage,
+                        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),
+                    threadId,
+                    meta: event.meta,
+                });
+                return;
+            }
+            try {
+                const reply = await runSlackAgent({
+                    prompt: userMessage,
+                    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);
+                yield agentOutput({
+                    agentId,
+                    content: `Slack agent error: ${message}`,
+                    threadId,
+                    meta: event.meta,
+                });
+            }
+        });
+        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.
+            }
+        });
+    },
+});

package/dist/logger.js

@@ -0,0 +1,17 @@
+const PREFIX = "[slack]";
+function formatMessage(message, details) {
+    if (!details || Object.keys(details).length === 0)
+        return message;
+    return `${message} ${JSON.stringify(details)}`;
+}
+export const log = {
+    info(message, details) {
+        console.log(`${PREFIX} ${formatMessage(message, details)}`);
+    },
+    warn(message, details) {
+        console.warn(`${PREFIX} ${formatMessage(message, details)}`);
+    },
+    debug(message, details) {
+        console.debug(`${PREFIX} ${formatMessage(message, details)}`);
+    },
+};

package/dist/slack-agent.js

@@ -0,0 +1,27 @@
+import { createOpenAI } from "@ai-sdk/openai";
+import { generateText, stepCountIs } from "ai";
+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 openai = createOpenAI({ apiKey: args.openaiApiKey });
+    const mcpClient = await createSlackMcpClient({
+        botToken: args.botToken,
+        teamId: args.teamId,
+    });
+    try {
+        const tools = await mcpClient.tools();
+        const result = await generateText({
+            model: openai(args.model ?? "gpt-4o-mini"),
+            system: SYSTEM_PROMPT,
+            prompt: args.prompt,
+            tools,
+            stopWhen: stepCountIs(10),
+        });
+        return result.text.trim() || "Done.";
+    }
+    finally {
+        await mcpClient.close();
+    }
+}

package/dist/slack-mcp.js

@@ -0,0 +1,15 @@
+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,
+            },
+        }),
+    });
+}

package/dist/slack-post.js

@@ -0,0 +1,18 @@
+export async function postSlackMessage(args) {
+    const res = await fetch("https://slack.com/api/chat.postMessage", {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${args.token}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            channel: args.channel,
+            thread_ts: args.threadTs,
+            text: args.text,
+        }),
+    });
+    const body = (await res.json());
+    if (!body.ok) {
+        throw new Error(body.error ?? `Slack API error (${res.status})`);
+    }
+}

package/dist/slack-threads.js

@@ -0,0 +1,20 @@
+function slackThreadKey(channel, rootTs) {
+    return `${channel}:${rootTs}`;
+}
+const activeSlackThreads = new Set();
+const threadHistories = new Map();
+export function markSlackThreadActive(channel, rootTs) {
+    activeSlackThreads.add(slackThreadKey(channel, rootTs));
+}
+export function isSlackThreadActive(channel, rootTs) {
+    return activeSlackThreads.has(slackThreadKey(channel, rootTs));
+}
+export function getSlackThreadHistory(channel, rootTs) {
+    return threadHistories.get(slackThreadKey(channel, rootTs)) ?? [];
+}
+export function appendSlackThreadHistory(channel, rootTs, ...messages) {
+    const key = slackThreadKey(channel, rootTs);
+    const history = threadHistories.get(key) ?? [];
+    history.push(...messages);
+    threadHistories.set(key, history);
+}

package/dist/slack-verify.d.ts

@@ -0,0 +1 @@
+export declare function verifySlackSignature(signingSecret: string, rawBody: Buffer, timestamp: string | undefined, signature: string | undefined): boolean;

package/dist/slack-verify.js

@@ -0,0 +1,20 @@
+import crypto from "node:crypto";
+export function verifySlackSignature(signingSecret, rawBody, timestamp, signature) {
+    if (!signingSecret || !timestamp || !signature)
+        return false;
+    const age = Math.abs(Date.now() / 1000 - Number(timestamp));
+    if (!Number.isFinite(age) || age > 60 * 5)
+        return false;
+    const base = `v0:${timestamp}:${rawBody.toString("utf8")}`;
+    const hmac = crypto
+        .createHmac("sha256", signingSecret)
+        .update(base)
+        .digest("hex");
+    const expected = `v0=${hmac}`;
+    try {
+        return crypto.timingSafeEqual(Buffer.from(expected), Buffer.from(signature));
+    }
+    catch {
+        return false;
+    }
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@meetopenbot/slack",
+  "version": "0.0.1",
+  "description": "Slack Events API ingress, simple agent replies, and thread delivery for OpenBot",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "dependencies": {
+    "@ai-sdk/mcp": "^2.0.14",
+    "@ai-sdk/openai": "^4.0.15",
+    "@meetopenbot/plugin-sdk": "^0.1.8",
+    "ai": "^7.0.29"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.1",
+    "typescript": "^5.9.3"
+  }
+}