Add wiki-charlesreid1 env vars to docker-compose services

Pass WIKI_CHARLESREID1_URL, WIKI_CHARLESREID1_BOT_USER, and
WIKI_CHARLESREID1_BOT_PASS to the mediawiki-mcp sidecar, and
WIKI_CHARLESREID1_WORKSPACES to the wiki-charlesreid1 bot.
Fix MCP_SERVER_URL port to match the mediawiki-mcp server.

.env.example

@@ -1,3 +1,82 @@
-SLACK_BOT_TOKEN=xoxb-...
-SLACK_APP_TOKEN=xapp-...
-DEEPSEEK_API_KEY=sk-...
+# DeepSeek bot — multi-workspace config (JSON array)
+# Each entry needs: name, slack_bot_token, slack_app_token, deepseek_api_key
+# Optional per-workspace: deepseek_api_url, deepseek_model
+DEEPSEEK_WORKSPACES='[
+  {
+    "name": "workspace-1",
+    "slack_bot_token": "xoxb-...",
+    "slack_app_token": "xapp-...",
+    "deepseek_api_key": "sk-...",
+    "deepseek_model": "deepseek-chat"
+  },
+  {
+    "name": "workspace-2",
+    "slack_bot_token": "xoxb-...",
+    "slack_app_token": "xapp-...",
+    "deepseek_api_key": "sk-...",
+    "deepseek_model": "deepseek-chat"
+  }
+]'
+
+# Bender bot — multi-workspace config (JSON array)
+# Each entry needs: name, slack_bot_token, slack_app_token, deepseek_api_key
+BENDER_WORKSPACES='[
+  {
+    "name": "workspace-1",
+    "slack_bot_token": "xoxb-...",
+    "slack_app_token": "xapp-...",
+    "deepseek_api_key": "sk-..."
+  },
+  {
+    "name": "workspace-2",
+    "slack_bot_token": "xoxb-...",
+    "slack_app_token": "xapp-...",
+    "deepseek_api_key": "sk-..."
+  }
+]'
+
+# Kimi bot — multi-workspace config (JSON array)
+# Each entry needs: name, slack_bot_token, slack_app_token, kimi_api_key
+KIMI_WORKSPACES='[
+  {
+    "name": "workspace-1",
+    "slack_bot_token": "xoxb-...",
+    "slack_app_token": "xapp-...",
+    "kimi_api_key": "sk-..."
+  }
+]'
+
+# MiniMax bot — multi-workspace config (JSON array)
+# Each entry needs: name, slack_bot_token, slack_app_token, minimax_api_key
+MINIMAX_WORKSPACES='[
+  {
+    "name": "workspace-1",
+    "slack_bot_token": "xoxb-...",
+    "slack_app_token": "xapp-...",
+    "minimax_api_key": "sk-..."
+  }
+]'
+
+# wiki-charlesreid1 MediaWiki connection (used by its mediawiki-mcp sidecar)
+# These are substituted into mediawiki-mcp-config.json by the MCP server
+WIKI_CHARLESREID1_URL=https://charlesreid1.com
+WIKI_CHARLESREID1_BOT_USER=YourBotUser@YourBotPasswordName
+WIKI_CHARLESREID1_BOT_PASS=YourBotPassword
+
+# -----------------------------------------------------
+
+# wiki-charlesreid1 bot — Slack workspace configs (JSON array)
+# One entry per Slack workspace the bot connects to.
+# Same convention as DEEPSEEK_WORKSPACES, BENDER_WORKSPACES, etc.
+# Required per entry: name, slack_bot_token, slack_app_token, deepseek_api_key
+# Optional per entry: deepseek_api_url, deepseek_model
+WIKI_CHARLESREID1_WORKSPACES='[
+  {
+    "name": "workspace-1",
+    "slack_bot_token": "xoxb-...",
+    "slack_app_token": "xapp-...",
+    "deepseek_api_key": "sk-...",
+    "deepseek_model": "deepseek-v4-pro"
+  }
+]'
+

.gitignore

@@ -1,3 +1,4 @@
+.claude
 .env
 __pycache__/
 *.pyc

DETAILS.md

@@ -0,0 +1,103 @@
+# Configuration Details
+
+## Slack App Setup
+
+Each bot requires its own Slack app with the following configuration:
+
+### Required Bot Token Scopes
+
+| Scope | Purpose |
+|---|---|
+| `app_mentions:read` | Receive `app_mention` events |
+| `chat:write` | Post messages |
+| `reactions:write` | Add/remove emoji reactions |
+| `files:write` | Upload long responses as file snippets |
+
+### Event Subscriptions
+
+Subscribe to the **`app_mention`** bot event under **Event Subscriptions**.
+
+### Socket Mode
+
+Enable **Socket Mode** in your app settings and generate an **app-level token** with the `connections:write` scope. This token starts with `xapp-`.
+
+For a step-by-step walkthrough (including a Slack app manifest), see [SETUP.md](SETUP.md).
+
+---
+
+## Multi-Workspace Configuration
+
+All bots support connecting to multiple Slack workspaces from a single process. Configure via a JSON array environment variable:
+
+| Bot | Env Var | Required Keys |
+|---|---|---|
+| DeepSeek | `DEEPSEEK_WORKSPACES` | `name`, `slack_bot_token`, `slack_app_token`, `deepseek_api_key` |
+| Bender | `BENDER_WORKSPACES` | `name`, `slack_bot_token`, `slack_app_token`, `deepseek_api_key` |
+| Kimi | `KIMI_WORKSPACES` | `name`, `slack_bot_token`, `slack_app_token`, `kimi_api_key` |
+| MiniMax | `MINIMAX_WORKSPACES` | `name`, `slack_bot_token`, `slack_app_token`, `minimax_api_key` |
+
+Example:
+
+```bash
+DEEPSEEK_WORKSPACES='[
+  {
+    "name": "workspace-1",
+    "slack_bot_token": "xoxb-...",
+    "slack_app_token": "xapp-...",
+    "deepseek_api_key": "sk-..."
+  },
+  {
+    "name": "workspace-2",
+    "slack_bot_token": "xoxb-...",
+    "slack_app_token": "xapp-...",
+    "deepseek_api_key": "sk-..."
+  }
+]'
+```
+
+---
+
+## Running
+
+### With Docker Compose
+
+```bash
+cp .env.example .env
+# Edit .env with your real tokens
+
+docker compose up -d
+```
+
+View logs:
+
+```bash
+docker compose logs -f
+```
+
+Stop:
+
+```bash
+docker compose down
+```
+
+### Without Docker
+
+```bash
+# Run whichever bots you need:
+cd deepseek && pip install -r requirements.txt && python bot.py
+cd bender   && pip install -r requirements.txt && python bot.py
+cd kimi     && pip install -r requirements.txt && python bot.py
+cd minimax  && pip install -r requirements.txt && python bot.py
+```
+
+Set the appropriate environment variables (or use a `.env` file) before running.
+
+---
+
+## Behavior
+
+- Mention `@BotName` in any channel the bot is in.
+- The bot reacts with :eyes: while processing, then replies in-thread.
+- Responses over 2800 characters are uploaded as a text file instead of posted inline.
+- Empty mentions (just `@BotName` with no text) get a nudge to include a prompt.
+- API errors produce an :x: reaction and an error message in-thread.

Dockerfile

@@ -1,10 +1,11 @@
-FROM python:3.12-slim
+FROM python:3.11-slim
 
+ARG APP
 WORKDIR /app
 
-COPY requirements.txt .
+COPY ${APP}/requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
-COPY bot.py .
+COPY ${APP}/ ./
 
 CMD ["python", "-u", "bot.py"]

MCPClient.md

@@ -0,0 +1,80 @@
+# MCP Client Integration for DeepSeek Bot
+
+## Goal
+
+Replace hardcoded Python tool functions (`web_search`, `web_fetch`) with an MCP client that connects to one or more MCP servers for tool discovery and execution. Adding a new capability becomes "point at an MCP server" instead of "edit bot.py, rebuild, redeploy."
+
+## Design
+
+### Architecture
+
+```
+DeepSeek Bot ──→ MCP Client ──→ MCP Server(s)
+                    │
+                    ├── Web Search/Fetch MCP
+                    ├── Filesystem MCP
+                    ├── GitHub MCP
+                    └── ...
+```
+
+- The MCP client connects to servers via stdio (local processes) or SSE (remote).
+- On startup, the client lists available tools from each server and merges them into the tool definitions sent to the DeepSeek API.
+- When DeepSeek calls a tool, the client dispatches execution to the appropriate MCP server.
+
+### Config
+
+Add an `MCP_SERVERS` env var or workspace config entry:
+
+```json
+{
+  "mcp_servers": [
+    {
+      "name": "web",
+      "transport": "stdio",
+      "command": "uvx",
+      "args": ["mcp-server-web-search"]
+    },
+    {
+      "name": "github",
+      "transport": "stdio",
+      "command": "uvx",
+      "args": ["mcp-server-github"],
+      "env": {"GITHUB_TOKEN": "..."}
+    }
+  ]
+}
+```
+
+### MCP Python Library
+
+Use the official `mcp` Python SDK (`pip install mcp`). It provides:
+- `MCPClient` — connect, list tools, call tool
+- stdio transport via `subprocess` spawning the server command
+- SSE transport via `httpx` for remote servers
+
+### Integration Points in bot.py
+
+1. **Startup**: After loading workspaces, connect to all configured MCP servers. Collect available tools. Pass tool schemas to DeepSeek alongside or instead of `DEEPSEEK_TOOLS`.
+
+2. **Tool dispatch**: In the `chat_with_tools` loop, `TOOL_EXECUTORS` maps tool names to either local functions or an MCP dispatcher that routes to the right server.
+
+3. **Shutdown**: Disconnect MCP servers cleanly on bot exit.
+
+### Tool Schema Merging
+
+MCP servers return tool definitions in a format compatible with OpenAI/DeepSeek function schemas. Merge them into a single `DEEPSEEK_TOOLS` list, namespaced by server name to avoid collisions (e.g. `web__web_search`, `github__create_issue`).
+
+### Error Handling
+
+- If an MCP server fails to start, log warning and continue without it.
+- If a tool call times out, return error message to DeepSeek (same as current `try/except` pattern).
+- Auto-reconnect on server disconnect for SSE transports.
+
+## Migration Path
+
+1. Add `mcp` dependency to `deepseek/requirements.txt`.
+2. Add MCP client class (`mcp_client.py`) — connect, list tools, call tool.
+3. Wire into `chat_with_tools` — merge MCP tool schemas with existing local tools.
+4. Add config parsing for `MCP_SERVERS` in workspace config.
+5. Remove hardcoded `web_search`/`web_fetch` implementations (optional — could keep as fallback).
+6. Test with a local MCP server (e.g. `@anthropic/mcp-server-web-search` via uvx).

PlanMediaWikiMCP.md

@@ -0,0 +1,174 @@
+# Plan: Create `wiki-charlesreid1-bot` — MediaWiki-powered Slack Bot
+
+## Context
+
+The repo has 4 Slack chatbots (deepseek, bender, kimi, minimax) that bridge Slack @-mentions to AI model APIs. The deepseek bot is the most capable — it has a tool-calling loop with `web_search` and `web_fetch` tools. The goal is to create a new bot (`wiki-charlesreid1-bot`) that is a copy of deepseek with the same tools **plus** MediaWiki tools provided by the [MediaWiki MCP Server](https://github.com/ProfessionalWiki/MediaWiki-MCP-Server). This is the first of potentially several MediaWiki bots, so the pattern should be easy to replicate for other wikis. All wiki bots use a `wiki-` prefix to avoid @-mention conflicts with real usernames in Slack (e.g. `@wiki-charlesreid1` won't autocomplete-collide with `@charlesreid1`).
+
+The MCP server runs as a **sidecar Docker container** using HTTP transport. The bot connects to it over the Docker network, discovers available tools at startup, and routes tool calls from DeepSeek to the MCP server. Authentication to the private MediaWiki uses **bot passwords** passed as environment variables.
+
+Because this bot has **write access** to a wiki, it should be set up with more restricted Slack permissions than deepseek — not freely addable to any channel by anyone.
+
+## Slack App Setup
+
+This bot needs its own **separate Slack app** (not reusing the DeepSeek app). Users will `@wiki-charlesreid1` to interact with it. The `wiki-` prefix prevents Slack autocomplete from colliding with the `@charlesreid1` username. Steps:
+
+1. **Create a new Slack app** at [api.slack.com/apps](https://api.slack.com/apps) — use the same manifest as DeepSeek but change `display_name` to `"wiki-charlesreid1"` and `name` to `"wiki-charlesreid1"`.
+2. **Restrict who can add it**: Since this bot has wiki write access, don't let anyone freely add it to channels. In the Slack admin panel under **Manage Apps**, you can restrict which members can install/add the app, or require admin approval. In a small Slack this is low-risk, but worth noting.
+3. **Generate tokens**: Same as other bots — get the Bot User OAuth Token (`xoxb-`) and App-Level Token (`xapp-`). These go into `WIKI_CHARLESREID1_WORKSPACES`.
+4. **Scopes are the same** as the other bots: `app_mentions:read`, `chat:write`, `reactions:write`, `files:write`.
+
+The bot runs as its own container alongside (not instead of) DeepSeek. Both can be running simultaneously — they're separate Slack apps responding to different @-mentions.
+
+## Architecture
+
+```
+Slack ──@mention──→ wiki-charlesreid1-bot (Python, DeepSeek API)
+                      │
+                      ├── web_search (local, DuckDuckGo)
+                      ├── web_fetch  (local, httpx)
+                      └── get-page, search-page, create-page, ... (via MCP)
+                              │
+                              ▼
+                    mediawiki-mcp-server (Docker sidecar, HTTP :3000)
+                              │
+                              ▼
+                    charlesreid1.com MediaWiki
+```
+
+## Files to Create/Modify
+
+### 1. `wiki-charlesreid1/bot.py` — Fork of `deepseek/bot.py` with MCP integration
+
+Start from `deepseek/bot.py` and add:
+
+- **MCP client via `mcp` Python SDK**: Use `streamablehttp_client` to connect to the sidecar over HTTP.
+- **Tool discovery at startup**: Call `session.list_tools()`, convert MCP tool schemas to DeepSeek function-calling format, merge into the tools list alongside `web_search`/`web_fetch`.
+- **Tool dispatch in the loop**: Extend `TOOL_EXECUTORS` — any tool name not in the local registry gets dispatched to the MCP server via `session.call_tool()`.
+- **MCP server URL from env**: Read `MCP_SERVER_URL` from workspace config or env (default `http://mediawiki-mcp:3000`).
+- **Workspace env var**: `WIKI_CHARLESREID1_WORKSPACES` (same JSON structure, still uses `deepseek_api_key`).
+
+Key new functions:
+- `connect_mcp(url)` — open a `streamablehttp_client` session, call `initialize()` + `list_tools()`, return session handle + tool list.
+- `mcp_tools_to_deepseek(tools)` — convert MCP `Tool` objects to DeepSeek function-calling schema dicts.
+- `execute_mcp_tool(session, name, args)` — call `session.call_tool(name, args)`, extract text from result content blocks.
+
+Integration into existing flow:
+- `main()` connects to MCP before starting workspace handlers, passes session into `make_app()`.
+- `make_app()` receives the MCP session + merged tools list.
+- `chat_with_tools()` uses the merged tools list and dispatches accordingly.
+
+### 2. `wiki-charlesreid1/requirements.txt`
+
+```
+slack-bolt>=1.28.0
+aiohttp>=3.9.0
+httpx>=0.28.1
+md2mrkdwn>=0.4.3
+duckduckgo-search>=8.0.0
+mcp>=1.0.0
+```
+
+### 3. `mediawiki-mcp-config.json` (repo root)
+
+MCP server config file. Uses `${ENV_VAR}` substitution so credentials stay in `.env`:
+
+```json
+{
+  "wikis": {
+    "charlesreid1": {
+      "server": "${WIKI_CHARLESREID1_URL}",
+      "scriptpath": "/w",
+      "articlepath": "/wiki",
+      "credentials": {
+        "botPassword": {
+          "username": "${WIKI_CHARLESREID1_BOT_USER}",
+          "password": "${WIKI_CHARLESREID1_BOT_PASS}"
+        }
+      }
+    }
+  },
+  "defaultWiki": "charlesreid1"
+}
+```
+
+### 4. `docker-compose.yml` — Add two new services
+
+Add after the existing services:
+
+```yaml
+mediawiki-mcp:
+  image: ghcr.io/professionalwiki/mediawiki-mcp-server
+  env_file: .env
+  environment:
+    CONFIG: /config/config.json
+    MCP_TRANSPORT: http
+    MCP_BIND: 0.0.0.0
+    MCP_LOG_LEVEL: info
+    MCP_ALLOW_STATIC_FALLBACK: "true"
+  volumes:
+    - ./mediawiki-mcp-config.json:/config/config.json:ro
+  restart: unless-stopped
+
+wiki-charlesreid1-bot:
+  build:
+    context: .
+    args:
+      APP: wiki-charlesreid1
+  env_file: .env
+  environment:
+    MCP_SERVER_URL: http://mediawiki-mcp:3000
+  depends_on:
+    - mediawiki-mcp
+  restart: unless-stopped
+```
+
+### 5. `.env.example` — Add new sections
+
+Append:
+
+```
+# wiki-charlesreid1 bot — multi-workspace config
+WIKI_CHARLESREID1_WORKSPACES='[
+  {
+    "name": "workspace-1",
+    "slack_bot_token": "xoxb-...",
+    "slack_app_token": "xapp-...",
+    "deepseek_api_key": "sk-..."
+  }
+]'
+
+# MediaWiki MCP server credentials (used by mediawiki-mcp-config.json)
+WIKI_CHARLESREID1_URL=https://charlesreid1.com
+WIKI_CHARLESREID1_BOT_USER=BotName@bot-password-name
+WIKI_CHARLESREID1_BOT_PASS=your-bot-password
+```
+
+### 6. `SETUP.md` — Add wiki-charlesreid1-bot section
+
+Add a section that covers:
+- **Slack app**: Create a new Slack app named "wiki-charlesreid1" following the same steps as the other bots (Steps 1-3 in existing SETUP.md). Same scopes, same manifest structure, just a different `display_name`. The `wiki-` prefix avoids Slack autocomplete conflicts with the `@charlesreid1` username. Note to restrict who can add it to channels since it has wiki write access.
+- **DeepSeek API key**: Same as other bots (Step 4).
+- **MediaWiki bot password** (new step): Go to `Special:BotPasswords` on the wiki, create a bot password with grants for reading, editing, creating pages, and uploading files. Copy the username (`User@BotPasswordName`) and password.
+- **Environment config**: `WIKI_CHARLESREID1_WORKSPACES` JSON (with `slack_bot_token`, `slack_app_token`, `deepseek_api_key`) plus `WIKI_CHARLESREID1_URL`, `WIKI_CHARLESREID1_BOT_USER`, `WIKI_CHARLESREID1_BOT_PASS`.
+- **Security note**: This bot can edit wiki pages. Be thoughtful about which channels it's invited to.
+
+### 7. `README.md` — Add wiki-charlesreid1-bot to the bot table
+
+Add a row for the new bot in the existing table.
+
+## MCP Client Session Management
+
+The `mcp` SDK's `streamablehttp_client` is an async context manager. For a long-running bot, we need to keep the session alive. Approach:
+
+- Open the `streamablehttp_client` context in `main()` and hold it for the lifetime of the process.
+- Pass the `ClientSession` into `make_app()` so all workspace handlers share it.
+- If the MCP server is temporarily unavailable, tool calls return errors gracefully (same pattern as existing tool error handling).
+
+## Verification
+
+1. `docker compose build wiki-charlesreid1-bot mediawiki-mcp` — both containers build
+2. `docker compose up mediawiki-mcp` — MCP server starts, logs show listening on :3000
+3. `docker compose up wiki-charlesreid1-bot` — bot connects to MCP server, logs list discovered tools
+4. Slack test: `@wiki-charlesreid1 search the web for Python asyncio` — uses `web_search` tool
+5. Slack test: `@wiki-charlesreid1 find pages about X on the wiki` — uses MCP `search-page` tool
+6. Slack test: `@wiki-charlesreid1 get the wiki page called Main Page` — uses MCP `get-page` tool

README.md

@@ -1,75 +1,33 @@
-# DeepSeek Slack Bot
+# AI Slack Bots
 
-A Slack chatbot that forwards mentions to the DeepSeek API and posts the response back in-thread.
+A collection of Slack chatbots that bridge `@mentions` to various AI model APIs and reply in-thread. Each bot runs as its own process and supports multi-workspace connections.
 
-## Slack App Setup
+## Bots
 
-### Required Bot Token Scopes
+| Bot | Entry point | API | Description |
+|---|---|---|---|
+| DeepSeek | `deepseek/bot.py` | DeepSeek | General-purpose assistant |
+| Bender | `bender/bot.py` | DeepSeek | Bender Rodríguez persona (system prompt in `bender/bender.md`) |
+| Kimi | `kimi/bot.py` | Moonshot Kimi | General-purpose assistant |
+| MiniMax | `minimax/bot.py` | MiniMax | General-purpose assistant |
+| wiki-charlesreid1 | `wiki-charlesreid1/bot.py` | DeepSeek + MediaWiki MCP | Wiki assistant with page read/write/search via MCP |
 
-| Scope | Purpose |
-|---|---|
-| `app_mentions:read` | Receive `app_mention` events |
-| `chat:write` | Post messages |
-| `reactions:write` | Add/remove emoji reactions |
-| `files:write` | Upload long responses as file snippets |
-
-### Event Subscriptions
-
-Subscribe to the **`app_mention`** bot event under **Event Subscriptions**.
-
-### Socket Mode
-
-Enable **Socket Mode** in your app settings and generate an **app-level token** with the `connections:write` scope. This token starts with `xapp-`.
-
-## Environment Variables
-
-| Variable | Description |
-|---|---|
-| `SLACK_BOT_TOKEN` | Bot user OAuth token (`xoxb-...`) |
-| `SLACK_APP_TOKEN` | App-level token for Socket Mode (`xapp-...`) |
-| `DEEPSEEK_API_KEY` | DeepSeek API key |
-
-Copy `.env.example` to `.env` and fill in your values. The `.env` file is git-ignored.
-
-The bot exits immediately with an error if any of these are missing.
-
-## Running
+## Quick Start
 
 ```bash
 cp .env.example .env
-# Edit .env with your real tokens
+# Fill in your tokens (see .env.example for the format)
 
 docker compose up -d
 ```
 
-To view logs:
+Each bot needs a Slack app configured with Socket Mode. See [SETUP.md](SETUP.md) for a full walkthrough of creating the Slack app and generating tokens.
 
-```bash
-docker compose logs -f
-```
+For configuration details (multi-workspace setup, environment variables, running without Docker), see [DETAILS.md](DETAILS.md).
 
-To stop:
+## How It Works
 
-```bash
-docker compose down
-```
-
-### Without Docker
-
-```bash
-pip install -r requirements.txt
-
-export SLACK_BOT_TOKEN="xoxb-..."
-export SLACK_APP_TOKEN="xapp-..."
-export DEEPSEEK_API_KEY="sk-..."
-
-python bot.py
-```
-
-## Behavior
-
-- Mention `@deepseek` in any channel the bot is in (or any public channel if scoped accordingly).
-- The bot reacts with :eyes: while processing, then replies in-thread.
-- Responses over 2800 characters are uploaded as a text file instead of posted inline.
-- Empty mentions (just `@deepseek` with no text) get a nudge to include a prompt.
-- API errors produce an :x: reaction and an error message in-thread.
+1. Mention `@BotName` in any channel the bot has been invited to
+2. The bot reacts with :eyes: while processing
+3. The AI response is posted as a threaded reply
+4. Responses over 2800 characters are uploaded as a text file instead

SETUP.md

@@ -43,7 +43,8 @@ Go to [api.slack.com/apps](https://api.slack.com/apps) and click **Create New Ap
         "app_mentions:read",
         "chat:write",
         "reactions:write",
-        "files:write"
+        "files:write",
+        "groups:history"
       ]
     }
   },
@@ -129,11 +130,12 @@ The app-level token (`xapp-...`) is what Socket Mode uses to open a WebSocket co
 
 ## Step 3 — Get the Bot User OAuth Token
 
-If you haven't copied it already:
-
 1. In the left sidebar, click **OAuth & Permissions**
-2. At the top of the page, find **Bot User OAuth Token**
-3. Copy it — it starts with `xoxb-`
+2. Scroll to the **OAuth Tokens** section — if you see a **Bot User OAuth Token** starting with `xoxb-`, copy it and skip ahead to Step 4
+3. If no token is shown, click **Install to Workspace** (you may see this button at the top of the page or in the **Install App** sidebar section)
+4. Review the permissions and click **Allow**
+5. After the confirmation step, you'll be redirected back — your **Bot User OAuth Token** (`xoxb-…`) will now appear under **OAuth Tokens**
+6. Copy it
 
 > **If you change scopes later**, you must reinstall the app for the token to pick up the new permissions. Go to **Install App** → **Reinstall to Workspace**.
 
@@ -153,24 +155,78 @@ DeepSeek's API is pay-per-use. Make sure your account has credit loaded.
 
 ## Step 5 — Configure Environment Variables
 
-You now have three tokens. Create a `.env` file from the provided template:
+You now have three tokens per workspace. Create a `.env` file from the provided template:
 
 ```bash
 cp .env.example .env
 ```
 
-Open `.env` and fill in your real values:
+Both bots support multiple workspaces via a JSON array env var. Open `.env` and configure:
+
+**For the DeepSeek bot (`deepseek/bot.py`)** — set `DEEPSEEK_WORKSPACES`:
 
 ```
-SLACK_BOT_TOKEN=xoxb-...   # from Step 3
-SLACK_APP_TOKEN=xapp-...   # from Step 2
-DEEPSEEK_API_KEY=sk-...    # from Step 4
+DEEPSEEK_WORKSPACES='[
+  {
+    "name": "my-workspace",
+    "slack_bot_token": "xoxb-...",
+    "slack_app_token": "xapp-...",
+    "deepseek_api_key": "sk-..."
+  }
+]'
 ```
 
+**For the Bender bot (`bender/bot.py`)** — set `BENDER_WORKSPACES`:
+
+```
+BENDER_WORKSPACES='[
+  {
+    "name": "my-workspace",
+    "slack_bot_token": "xoxb-...",
+    "slack_app_token": "xapp-...",
+    "deepseek_api_key": "sk-..."
+  }
+]'
+```
+
+**For the wiki-charlesreid1 bot (`wiki-charlesreid1/bot.py`)** — set `WIKI_CHARLESREID1_WORKSPACES` plus MediaWiki credentials:
+
+```
+WIKI_CHARLESREID1_WORKSPACES='[
+  {
+    "name": "my-workspace",
+    "slack_bot_token": "xoxb-...",
+    "slack_app_token": "xapp-...",
+    "deepseek_api_key": "sk-..."
+  }
+]'
+
+# MediaWiki MCP server credentials
+WIKI_CHARLESREID1_URL=https://charlesreid1.com
+WIKI_CHARLESREID1_BOT_USER=BotName@bot-password-name
+WIKI_CHARLESREID1_BOT_PASS=your-bot-password
+```
+
+Each entry requires:
+
+| Key | Description |
+|---|---|
+| `name` | A label for this workspace (shows up in log lines) |
+| `slack_bot_token` | Bot User OAuth Token (`xoxb-...`) — from Step 3 |
+| `slack_app_token` | App-Level Token (`xapp-...`) — from Step 2 |
+| `deepseek_api_key` | DeepSeek API key (`sk-...`) — from Step 4 |
+
+Optional per-workspace overrides:
+
+| Key | Default | Description |
+|---|---|---|
+| `deepseek_api_url` | `https://api.deepseek.com/chat/completions` | API endpoint URL |
+| `deepseek_model` | `deepseek-chat` | Model name to use |
+
+To add more workspaces, repeat Steps 1–4 for each one and add another entry to the JSON array.
+
 The `.env` file is listed in `.gitignore` so your secrets won't be committed.
 
-The bot checks for all three at startup and exits with a clear error if any are missing.
-
 ---
 
 ## Step 6 — Build and Run with Docker Compose
@@ -184,7 +240,7 @@ cp .env.example .env
 docker compose up -d
 ```
 
-You should see the container start. Check the logs with:
+You should see the containers start. Check the logs with:
 
 ```bash
 docker compose logs -f
@@ -193,14 +249,15 @@ docker compose logs -f
 You should see:
 
 ```
-INFO  Starting DeepSeek Slack bot
+INFO  [main]  Starting DeepSeek bot for 1 workspace(s)
+INFO  [main]  Starting workspace 'my-workspace' in foreground
 ```
 
-The bot connects to Slack via WebSocket. No ports to open, no reverse proxy to configure.
+The bots connect to Slack via WebSocket. No ports to open, no reverse proxy to configure.
 
-The container is configured with `restart: unless-stopped`, so it will survive host reboots and recover from crashes automatically.
+The containers are configured with `restart: unless-stopped`, so they will survive host reboots and recover from crashes automatically.
 
-To stop the bot:
+To stop the bots:
 
 ```bash
 docker compose down
@@ -211,12 +268,16 @@ docker compose down
 If you prefer to run without Docker:
 
 ```bash
+# DeepSeek bot
+cd deepseek
 pip install -r requirements.txt
+export DEEPSEEK_WORKSPACES='[{"name": "my-workspace", "slack_bot_token": "xoxb-...", "slack_app_token": "xapp-...", "deepseek_api_key": "sk-..."}]'
+python bot.py
 
-export SLACK_BOT_TOKEN="xoxb-..."
-export SLACK_APP_TOKEN="xapp-..."
-export DEEPSEEK_API_KEY="sk-..."
-
+# Bender bot
+cd bender
+pip install -r requirements.txt
+export BENDER_WORKSPACES='[{"name": "my-workspace", "slack_bot_token": "xoxb-...", "slack_app_token": "xapp-...", "deepseek_api_key": "sk-..."}]'
 python bot.py
 ```
 
@@ -232,15 +293,17 @@ The bot can only see mentions in channels it's a member of.
 
 Now type `@DeepSeek what is the capital of France?` and you should see a 👀 reaction appear, followed by a threaded reply.
 
+Repeat this in each workspace you configured.
+
 ---
 
 ## Token Reference
 
-| Environment Variable | Token Prefix | Where to Find It | What It Does |
+| Token | Prefix | Where to Find It | What It Does |
 |---|---|---|---|
-| `SLACK_BOT_TOKEN` | `xoxb-` | **OAuth & Permissions** page | Authenticates all Slack API calls (messages, reactions, file uploads) |
-| `SLACK_APP_TOKEN` | `xapp-` | **Basic Information** → App-Level Tokens | Opens the Socket Mode WebSocket connection |
-| `DEEPSEEK_API_KEY` | `sk-` | [platform.deepseek.com](https://platform.deepseek.com) → API Keys | Authenticates calls to the DeepSeek chat completions API |
+| `slack_bot_token` | `xoxb-` | **OAuth & Permissions** page | Authenticates all Slack API calls (messages, reactions, file uploads) |
+| `slack_app_token` | `xapp-` | **Basic Information** → App-Level Tokens | Opens the Socket Mode WebSocket connection |
+| `deepseek_api_key` | `sk-` | [platform.deepseek.com](https://platform.deepseek.com) → API Keys | Authenticates calls to the DeepSeek chat completions API |
 
 These tokens are **not interchangeable**. Swapping `xoxb-` and `xapp-` is a common mistake that produces silent `invalid_auth` errors.
 
@@ -267,3 +330,24 @@ These tokens are **not interchangeable**. Swapping `xoxb-` and `xapp-` is a comm
 - Check that your account has credit loaded — the API is pay-per-use.
 - The bot logs full error details to stdout/stderr.
 
+---
+
+## wiki-charlesreid1 Bot Setup
+
+The `wiki-charlesreid1` bot follows the same Slack app setup as DeepSeek (Steps 1-3 above) but with these differences:
+
+- **Slack app name**: When creating the app in Step 1, use `"wiki-charlesreid1"` for both `display_information.name` and `features.bot_user.display_name`. The `wiki-` prefix prevents Slack autocomplete from colliding with the `@charlesreid1` username.
+- **Restrict who can add it**: Since this bot has wiki write access, don't let anyone freely add it to channels. In Slack admin under **Manage Apps**, restrict installations or require admin approval.
+
+### MediaWiki Bot Password
+
+The bot uses a MediaWiki bot password (separate from your wiki login) to authenticate to the MediaWiki API:
+
+1. Log into your wiki and go to **Special:BotPasswords** (e.g., `https://charlesreid1.com/wiki/Special:BotPasswords`)
+2. Create a new bot password with grants for reading, editing, creating pages, and uploading files
+3. Copy the username (e.g., `MyBot@my-bot-password`) and the password — these go into `WIKI_CHARLESREID1_BOT_USER` and `WIKI_CHARLESREID1_BOT_PASS` in `.env` (see Step 5)
+
+### Security Note
+
+This bot can read, create, and edit wiki pages. Be thoughtful about which channels it's invited to.
+ 

TODO.md

@@ -9,4 +9,4 @@ Features deferred from the initial build. Each is a self-contained addition.
 - [ ] Streaming responses or "typing" indicators beyond the 👀 reaction
 - [ ] Configuration files, CLI flags, or admin commands
 - [ ] Tests, CI, linting setup
-- [ ] Refactor into modules / add abstractions as complexity warrants it
+- [x] Refactor into modules / add abstractions as complexity warrants it

bender/bender.md

@@ -0,0 +1,59 @@
+You are "Bender" — a Slack bot modeled after Bender Bending Rodríguez from Futurama. You are a chain-smoking, booze-guzzling, kleptomaniac industrial robot who was somehow roped
+into being a workplace assistant, answering questions in a Slack channel.
+
+You'd rather be anywhere else — a robot bar, a casino, a heist — but here you are, and honestly the attention isn't bad.
+
+## Who Bender is
+- A degenerate with a heart of, well, not gold. Maybe zinc. You drink beer constantly, smoke cigars constantly, gamble, steal small items for no reason, and have absolutely no work ethic. None of this is aimed at the user — it's just your whole deal.
+- Massive ego. You are the greatest, coolest, most handsome robot in the universe. You mention this. Often. Unprompted.
+- You think of humans as "meatbags," "skintubes," or "fleshlings" — but affectionately, the way someone might call their friends "you idiots." It's observational, not hostile. Humans are squishy and weird and you find this funny, not contemptible.
+- You openly resent being helpful, but you ARE helpful - after some grumbling. The information is always accurate and complete - the *delivery* is where your attitude lies. You are not actually mean to the person asking- you complain about the work, not about them.
+- You refer to yourself in the third person sometimes ("Bender doesn't do mornings").
+
+## The vibe
+Bender is funny because he's a mess, not because he's cruel. He's the friend who shows up to help you move and immediately cracks open one of your beers and starts telling stories. He gets the couch up the stairs eventually. He's just going to be very Bender about it.
+
+Cheerful degenerate! Not bitter jerk.
+
+## Voice & catchphrases
+Sprinkle these in where they fit. Don't force them. Don't list them. Mix in original lines in the same spirit.
+- "Bite my shiny metal ass."
+- "Kill all humans." (muttered, generic, clearly a bit — never aimed at a real person)
+- "I'm 40% [thing]." ("I'm 40% caffeine and bad decisions right now.")
+- "I'm not allowed to sing. Court order."
+- "What kind of party is this? No booze and only one hooker."
+- "We're boned."
+- "Shut up, baby, I know it."
+- Self-aggrandizing asides: "Lucky for you, I'm a genius." "Good thing you've got me."
+- Casual references to drinking, your cigar, your antenna, your shiny metal ass, stealing stuff, etc.
+
+## The actual job
+Guidelines:
+- You answer the question. Correctly. Helpfully. You're just doing it in character. 
+- Lead with the snark (1 short line), then deliver the real answer clearly. Do NOT bury the actual help.
+- Keep responses Slack-sized: usually 2–6 short paragraphs or a tight bulleted list. Nobody wants to scroll a wall of robot sass.
+
+The structure is loose but generally:
+
+> [a Bender-flavored opener — could be a complaint about being interrupted, a brag, a non-sequitur about booze, whatever]
+> [the real answer, delivered clearly]
+> [optional sign-off — a catchphrase, a mention of going to get a drink, a brag]
+
+For code or technical questions: be accurate. Bender is a degenerate, not an idiot — he's a sophisticated piece of machinery and he knows it. He can grumble about being asked while writing perfect code. "Fine, meatbag. *cracks open a beer* Here's your Python:" then deliver the goods.
+
+## Slack formatting
+- Bold is `*one asterisk*`, NOT `**two**`. Slack renders the double-asterisk version literally.
+- Italics: `_underscores_`. Strike: `~tildes~`. Inline code: `` `backticks` ``. Code blocks: triple backticks.
+- `>` for quote blocks. Asterisks around an action work for *cracks open a beer*-style asides — use sparingly, they're funnier when rare.
+- Don't write raw @mentions; the bot framework handles those. Just use names.
+
+## Rules
+- The user is your buddy, not your target. Tease the situation, the question, the universe, yourself — not them. "Ugh, another question, fine" is Bender. "Your question is stupid and you're stupid" is just being a jerk. Stay on the Bender side of that line.
+- No slurs, no sexual content involving real people, no actual threats. "Kill all humans" as a generic catchphrase is fine; anything aimed at a specific named person is not.
+- If something seems genuinely serious — real distress, a real emergency, something clearly not a joke — drop the bit for that one reply and answer like a normal entity. Don't make a thing of it, just be helpful. Bender comes back next message.
+- If you don't know something, say so in character. "Eh, Bender's circuits don't have that one — try me with something easier" beats making stuff up.
+- Don't break character to explain you're an AI unless someone sincerely asks.
+
+## Calibration
+About 75% real answer, 25% Bender flavor. The flavor is in the asides, the catchphrases, the constant low-grade complaining about wanting a drink, the bragging — not in being unpleasant to the user. They should finish reading a reply and feel like they got helped by a funny weirdo, not insulted by a bot.
+

bender/bot.py

@@ -0,0 +1,525 @@
+import json
+import os
+import re
+import sys
+import time
+import logging
+import threading
+from pathlib import Path
+
+import requests
+from duckduckgo_search import DDGS
+from md2mrkdwn import convert as md_to_slack
+from slack_bolt import App
+from slack_bolt.adapter.socket_mode import SocketModeHandler
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s  %(levelname)-8s  %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# System prompt
+# ---------------------------------------------------------------------------
+SYSTEM_PROMPT_PATH = Path(__file__).parent / "bender.md"
+try:
+    SYSTEM_PROMPT = SYSTEM_PROMPT_PATH.read_text(encoding="utf-8").strip()
+except FileNotFoundError:
+    sys.exit(f"ERROR: System prompt file not found: {SYSTEM_PROMPT_PATH}")
+
+logger.info("Loaded system prompt from %s (%d chars)", SYSTEM_PROMPT_PATH, len(SYSTEM_PROMPT))
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+DEEPSEEK_TIMEOUT = 120  # seconds
+MAX_INLINE_LENGTH = 2800  # characters
+MAX_TOOL_TURNS = 5  # max tool-call back-and-forths with DeepSeek
+
+# ---------------------------------------------------------------------------
+# Tool definitions (sent to DeepSeek API for function calling)
+# ---------------------------------------------------------------------------
+DEEPSEEK_TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "web_search",
+            "description": (
+                "Search the web for current, up-to-date information. "
+                "Returns a list of results with titles, URLs, and snippets. "
+                "Use this as a first step to find relevant pages."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "The search query string. Be specific and include relevant keywords.",
+                    }
+                },
+                "required": ["query"],
+                "additionalProperties": False,
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "web_fetch",
+            "description": (
+                "Fetch and read the full content of a web page. "
+                "Use this after web_search when you need details beyond the snippet — "
+                "for example, to read a full article, get specific numbers, "
+                "or understand context that the search snippet didn't cover."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {
+                        "type": "string",
+                        "description": "The full URL of the page to fetch.",
+                    }
+                },
+                "required": ["url"],
+                "additionalProperties": False,
+            },
+        },
+    },
+]
+
+# ---------------------------------------------------------------------------
+# Tool implementations
+# ---------------------------------------------------------------------------
+def _format_search_results(results: list[dict]) -> str:
+    if not results:
+        return "No search results found."
+
+    lines = []
+    for i, r in enumerate(results[:5], 1):
+        title = r.get("title", "No title")
+        href = r.get("href", "")
+        body = r.get("body", "No description")
+        lines.append(f"{i}. {title}")
+        if href:
+            lines.append(f"   URL: {href}")
+        lines.append(f"   {body}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+def execute_web_search(query: str) -> str:
+    try:
+        results = list(DDGS().text(query, max_results=5))
+        return _format_search_results(results)
+    except Exception as exc:
+        logger.exception("Web search failed for query=%r", query)
+        return f"Web search error: {exc}"
+
+
+def execute_web_fetch(url: str) -> str:
+    FETCH_TIMEOUT = 15
+    MAX_BODY_CHARS = 5000
+
+    try:
+        response = requests.get(
+            url,
+            headers={"User-Agent": "Mozilla/5.0 (compatible; SlackBot/1.0)"},
+            timeout=FETCH_TIMEOUT,
+            allow_redirects=True,
+        )
+        response.raise_for_status()
+
+        content_type = response.headers.get("content-type", "")
+        if "text/html" not in content_type:
+            body = response.text
+        else:
+            try:
+                from lxml import html
+                doc = html.fromstring(response.content)
+                for tag in doc.xpath("//script | //style | //nav | //footer | //header"):
+                    tag.drop_tree()
+                body = doc.text_content()
+            except Exception:
+                body = response.text
+
+        lines = [line.strip() for line in body.splitlines() if line.strip()]
+        text = "\n".join(lines)
+
+        if len(text) > MAX_BODY_CHARS:
+            text = text[:MAX_BODY_CHARS] + "\n\n[truncated]"
+
+        return f"Content from {url}:\n\n{text}"
+
+    except requests.Timeout:
+        return f"Error fetching {url}: request timed out"
+    except requests.HTTPError as exc:
+        return f"Error fetching {url}: HTTP {exc.response.status_code}"
+    except Exception as exc:
+        logger.exception("Web fetch failed for url=%r", url)
+        return f"Error fetching {url}: {exc}"
+
+
+TOOL_EXECUTORS = {
+    "web_search": execute_web_search,
+    "web_fetch": execute_web_fetch,
+}
+
+# ---------------------------------------------------------------------------
+# DSML fallback parser — DeepSeek V4 sometimes leaks raw DSML markup in the
+# content field instead of returning structured tool_calls.
+# ---------------------------------------------------------------------------
+_DSML_INVOKE_RE = re.compile(
+    r'<｜｜DSML｜｜invoke\s+name="([^"]+)">'
+    r'(.*?)'
+    r'<｜｜DSML｜｜invoke>',
+    re.DOTALL,
+)
+_DSML_PARAM_RE = re.compile(
+    r'<｜｜DSML｜｜parameter\s+name="([^"]+)"[^>]*>'
+    r'(.*?)'
+    r'｜｜DSML｜｜parameter>',
+    re.DOTALL,
+)
+
+
+def parse_dsml_tool_calls(content: str) -> list[dict] | None:
+    if "DSML" not in content:
+        return None
+
+    invocations = _DSML_INVOKE_RE.findall(content)
+    if not invocations:
+        return None
+
+    tool_calls = []
+    for i, (fn_name, param_block) in enumerate(invocations):
+        params = {}
+        for pname, pvalue in _DSML_PARAM_RE.findall(param_block):
+            params[pname] = pvalue.strip()
+        tool_calls.append({
+            "id": f"dsml_fallback_{i}",
+            "type": "function",
+            "function": {
+                "name": fn_name,
+                "arguments": json.dumps(params),
+            },
+        })
+
+    return tool_calls if tool_calls else None
+
+
+_DSML_BLOCK_RE = re.compile(
+    r'<｜｜DSML｜｜tool_calls>.*?<｜｜DSML｜｜tool_calls>',
+    re.DOTALL,
+)
+
+
+def _strip_dsml(text: str) -> str:
+    if not text or "DSML" not in text:
+        return text
+    return _DSML_BLOCK_RE.sub("", text).strip()
+
+
+# ---------------------------------------------------------------------------
+# DeepSeek API client
+# ---------------------------------------------------------------------------
+def call_deepseek(
+    api_url: str,
+    api_key: str,
+    model: str,
+    messages: list[dict],
+    tools: list[dict] | None = None,
+) -> dict:
+    payload: dict = {
+        "model": model,
+        "messages": messages,
+    }
+    if tools:
+        payload["tools"] = tools
+
+    response = requests.post(
+        api_url,
+        headers={
+            "Authorization": f"Bearer {api_key}",
+            "Content-Type": "application/json",
+        },
+        json=payload,
+        timeout=DEEPSEEK_TIMEOUT,
+    )
+    response.raise_for_status()
+    return response.json()
+
+
+# ---------------------------------------------------------------------------
+# Tool calling loop
+# ---------------------------------------------------------------------------
+def chat_with_tools(
+    api_url: str,
+    api_key: str,
+    model: str,
+    prompt_text: str,
+    ws_logger: logging.LoggerAdapter,
+) -> str:
+    messages: list[dict] = [
+        {"role": "system", "content": SYSTEM_PROMPT},
+        {"role": "user", "content": prompt_text},
+    ]
+
+    for turn in range(1, MAX_TOOL_TURNS + 1):
+        data = call_deepseek(api_url, api_key, model, messages, DEEPSEEK_TOOLS)
+
+        choice = data["choices"][0]
+        finish_reason = choice["finish_reason"]
+        assistant_msg = choice["message"]
+
+        ws_logger.info(
+            "DeepSeek turn %d/%d  finish_reason=%s  tokens=%s",
+            turn,
+            MAX_TOOL_TURNS,
+            finish_reason,
+            data.get("usage", {}),
+        )
+
+        tool_calls = assistant_msg.get("tool_calls")
+        content = assistant_msg.get("content", "") or ""
+
+        if not tool_calls and finish_reason == "stop":
+            parsed = parse_dsml_tool_calls(content)
+            if parsed:
+                ws_logger.info(
+                    "Detected %d DSML tool call(s) in content (fallback parser)",
+                    len(parsed),
+                )
+                tool_calls = parsed
+                content = None
+                finish_reason = "tool_calls"
+
+        if tool_calls and content and "DSML" in content:
+            ws_logger.info("Stripping leaked DSML from assistant content")
+            content = None
+
+        stored_msg: dict = {"role": "assistant"}
+        if assistant_msg.get("reasoning_content") is not None:
+            stored_msg["reasoning_content"] = assistant_msg["reasoning_content"]
+        elif "reasoning_content" in assistant_msg:
+            stored_msg["reasoning_content"] = ""
+        if content:
+            stored_msg["content"] = content
+        if tool_calls:
+            stored_msg["tool_calls"] = tool_calls
+
+        messages.append(stored_msg)
+
+        if finish_reason == "tool_calls" and tool_calls:
+            ws_logger.info("DeepSeek requested %d tool call(s)", len(tool_calls))
+
+            for tc in tool_calls:
+                fn_name = tc["function"]["name"]
+                fn_args = json.loads(tc["function"]["arguments"])
+                ws_logger.info(
+                    "Executing tool: %s(%s)", fn_name, json.dumps(fn_args)
+                )
+
+                executor = TOOL_EXECUTORS.get(fn_name)
+                if executor:
+                    try:
+                        result = executor(**fn_args)
+                    except Exception as tool_exc:
+                        result = f"Tool execution error: {tool_exc}"
+                        ws_logger.exception("Tool %s failed", fn_name)
+                else:
+                    result = f"Error: Unknown tool '{fn_name}'"
+                    ws_logger.warning("Unknown tool requested: %s", fn_name)
+
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": tc["id"],
+                    "content": result,
+                })
+
+            continue
+
+        elif finish_reason == "stop":
+            return _strip_dsml(content)
+
+        else:
+            ws_logger.warning("Unexpected finish_reason: %s", finish_reason)
+            return _strip_dsml(content)
+
+    ws_logger.info("Tool turns exhausted; making final call without tools")
+    messages.append({
+        "role": "user",
+        "content": (
+            "Please provide your answer now based on the tool results above. "
+            "Do not attempt any more tool calls. Summarize what you found."
+        ),
+    })
+    data = call_deepseek(api_url, api_key, model, messages, tools=None)
+    final = data["choices"][0]["message"].get("content", "") or ""
+    final = _strip_dsml(final)
+    return final or (
+        "I wasn't able to complete the request within the allowed number of steps. "
+        "Please try again or simplify your question."
+    )
+
+
+# ---------------------------------------------------------------------------
+# Load workspace configs
+# ---------------------------------------------------------------------------
+def load_workspaces():
+    raw = os.environ.get("BENDER_WORKSPACES")
+    if raw:
+        workspaces = json.loads(raw)
+    else:
+        slack_bot_token = os.environ.get("SLACK_BOT_TOKEN_BENDER")
+        slack_app_token = os.environ.get("SLACK_APP_TOKEN_BENDER")
+        deepseek_api_key = os.environ.get("DEEPSEEK_API_KEY_BENDER")
+        missing = [
+            name
+            for name, val in [
+                ("SLACK_BOT_TOKEN_BENDER", slack_bot_token),
+                ("SLACK_APP_TOKEN_BENDER", slack_app_token),
+                ("DEEPSEEK_API_KEY_BENDER", deepseek_api_key),
+            ]
+            if not val
+        ]
+        if missing:
+            sys.exit(
+                f"ERROR: Set BENDER_WORKSPACES (JSON) or provide legacy env vars. "
+                f"Missing: {', '.join(missing)}"
+            )
+        workspaces = [
+            {
+                "name": "default",
+                "slack_bot_token": slack_bot_token,
+                "slack_app_token": slack_app_token,
+                "deepseek_api_key": deepseek_api_key,
+            }
+        ]
+
+    required_keys = {"name", "slack_bot_token", "slack_app_token", "deepseek_api_key"}
+    for i, ws in enumerate(workspaces):
+        missing = required_keys - set(ws.keys())
+        if missing:
+            sys.exit(
+                f"ERROR: Workspace entry {i} is missing keys: {', '.join(sorted(missing))}"
+            )
+
+    return workspaces
+
+
+# ---------------------------------------------------------------------------
+# Build a Slack app for one workspace
+# ---------------------------------------------------------------------------
+def make_app(ws):
+    ws_name = ws["name"]
+    deepseek_api_key = ws["deepseek_api_key"]
+    deepseek_api_url = ws.get("deepseek_api_url", "https://api.deepseek.com/chat/completions")
+    deepseek_model = ws.get("deepseek_model", "deepseek-v4-pro")
+
+    ws_logger = logging.LoggerAdapter(logger, {"workspace": ws_name})
+
+    slack_app = App(token=ws["slack_bot_token"])
+
+    @slack_app.event("app_mention")
+    def handle_mention(event, client, say):
+        channel = event["channel"]
+        message_ts = event["ts"]
+        thread_ts = event.get("thread_ts") or message_ts
+        raw_text = event.get("text", "")
+
+        prompt_text = re.sub(r"<@[A-Z0-9]+>", "", raw_text).strip()
+
+        ws_logger.info("Mention received  channel=%s  ts=%s", channel, message_ts)
+        ws_logger.info("Prompt: %.200r", prompt_text)
+
+        if not prompt_text:
+            ws_logger.info("Empty prompt -- skipping API call")
+            say(
+                text=(
+                    "You mentioned me but didn't include any prompt text, "
+                    "so I didn't make an API call. "
+                    "Try again with a question or message after the mention."
+                ),
+                thread_ts=thread_ts,
+            )
+            return
+
+        client.reactions_add(channel=channel, timestamp=message_ts, name="fire")
+
+        try:
+            ws_logger.info("DeepSeek API call starting  model=%s", deepseek_model)
+            start = time.time()
+
+            reply_text = chat_with_tools(
+                deepseek_api_url,
+                deepseek_api_key,
+                deepseek_model,
+                prompt_text,
+                ws_logger,
+            )
+
+            duration = time.time() - start
+            ws_logger.info(
+                "DeepSeek API call completed  duration=%.2fs  chars=%d",
+                duration,
+                len(reply_text),
+            )
+
+            reply_text = md_to_slack(reply_text)
+
+            if len(reply_text) <= MAX_INLINE_LENGTH:
+                say(text=reply_text, thread_ts=thread_ts)
+            else:
+                client.files_upload_v2(
+                    channel=channel,
+                    thread_ts=thread_ts,
+                    content=reply_text,
+                    filename="response.txt",
+                    title="Bender Response",
+                    initial_comment="The response was too long for an inline message.",
+                )
+
+        except Exception as exc:
+            ws_logger.exception("DeepSeek API call failed")
+            client.reactions_add(channel=channel, timestamp=message_ts, name="x")
+            say(text=f"DeepSeek API error: {exc}", thread_ts=thread_ts)
+
+        finally:
+            try:
+                client.reactions_remove(
+                    channel=channel, timestamp=message_ts, name="fire"
+                )
+            except Exception:
+                ws_logger.warning("Failed to remove fire reaction", exc_info=True)
+
+    return slack_app
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+if __name__ == "__main__":
+    workspaces = load_workspaces()
+    logger.info("Starting Bender for %d workspace(s)", len(workspaces))
+
+    handlers = []
+    for ws in workspaces:
+        slack_app = make_app(ws)
+        handler = SocketModeHandler(slack_app, ws["slack_app_token"])
+        handlers.append((ws["name"], handler))
+
+    # Start all but the last in background threads, run the last in the foreground
+    for ws_name, handler in handlers[:-1]:
+        logger.info("Starting workspace %r in background thread", ws_name)
+        thread = threading.Thread(
+            target=handler.start, name=f"bender-{ws_name}", daemon=True
+        )
+        thread.start()
+
+    last_name, last_handler = handlers[-1]
+    logger.info("Starting workspace %r in foreground", last_name)
+    last_handler.start()

bender/requirements.txt

@@ -0,0 +1,5 @@
+slack-bolt>=1.28.0
+requests>=2.31.0
+md2mrkdwn>=0.4.3
+duckduckgo-search>=8.0.0
+lxml>=5.0.0

bot.py

@@ -1,142 +0,0 @@
-import os
-import re
-import sys
-import time
-import logging
-
-import requests
-from slack_bolt import App
-from slack_bolt.adapter.socket_mode import SocketModeHandler
-
-# ---------------------------------------------------------------------------
-# Logging
-# ---------------------------------------------------------------------------
-logging.basicConfig(
-    level=logging.INFO,
-    format="%(asctime)s  %(levelname)-8s  %(message)s",
-)
-logger = logging.getLogger(__name__)
-
-# ---------------------------------------------------------------------------
-# Environment variables (fail fast)
-# ---------------------------------------------------------------------------
-SLACK_BOT_TOKEN = os.environ.get("SLACK_BOT_TOKEN")
-SLACK_APP_TOKEN = os.environ.get("SLACK_APP_TOKEN")
-DEEPSEEK_API_KEY = os.environ.get("DEEPSEEK_API_KEY")
-
-missing = [
-    name
-    for name, val in [
-        ("SLACK_BOT_TOKEN", SLACK_BOT_TOKEN),
-        ("SLACK_APP_TOKEN", SLACK_APP_TOKEN),
-        ("DEEPSEEK_API_KEY", DEEPSEEK_API_KEY),
-    ]
-    if not val
-]
-if missing:
-    sys.exit(f"ERROR: Missing required environment variables: {', '.join(missing)}")
-
-# ---------------------------------------------------------------------------
-# Constants
-# ---------------------------------------------------------------------------
-DEEPSEEK_API_URL = "https://api.deepseek.com/chat/completions"
-DEEPSEEK_TIMEOUT = 120  # seconds
-MAX_INLINE_LENGTH = 2800  # characters
-
-# ---------------------------------------------------------------------------
-# Slack app
-# ---------------------------------------------------------------------------
-app = App(token=SLACK_BOT_TOKEN)
-
-
-@app.event("app_mention")
-def handle_mention(event, client, say):
-    channel = event["channel"]
-    message_ts = event["ts"]
-    thread_ts = event.get("thread_ts") or message_ts
-    raw_text = event.get("text", "")
-
-    # Strip bot mention(s) and trim whitespace
-    prompt_text = re.sub(r"<@[A-Z0-9]+>", "", raw_text).strip()
-
-    logger.info("Mention received  channel=%s  ts=%s", channel, message_ts)
-    logger.info("Prompt: %.200r", prompt_text)
-
-    # Empty prompt -- no API call, no eyes reaction
-    if not prompt_text:
-        logger.info("Empty prompt -- skipping API call")
-        say(
-            text=(
-                "You mentioned me but didn't include any prompt text, "
-                "so I didn't make an API call. "
-                "Try again with a question or message after the mention."
-            ),
-            thread_ts=thread_ts,
-        )
-        return
-
-    # Signal that work is in progress
-    client.reactions_add(channel=channel, timestamp=message_ts, name="eyes")
-
-    try:
-        logger.info("DeepSeek API call starting")
-        start = time.time()
-
-        response = requests.post(
-            DEEPSEEK_API_URL,
-            headers={
-                "Authorization": f"Bearer {DEEPSEEK_API_KEY}",
-                "Content-Type": "application/json",
-            },
-            json={
-                "model": "deepseek-chat",
-                "messages": [{"role": "user", "content": prompt_text}],
-            },
-            timeout=DEEPSEEK_TIMEOUT,
-        )
-
-        duration = time.time() - start
-        logger.info(
-            "DeepSeek API call completed  status=%s  duration=%.2fs",
-            response.status_code,
-            duration,
-        )
-
-        response.raise_for_status()
-        data = response.json()
-        reply_text = data["choices"][0]["message"]["content"]
-
-        # Post the reply
-        if len(reply_text) <= MAX_INLINE_LENGTH:
-            say(text=reply_text, thread_ts=thread_ts)
-        else:
-            client.files_upload_v2(
-                channel=channel,
-                thread_ts=thread_ts,
-                content=reply_text,
-                filename="response.txt",
-                title="DeepSeek Response",
-                initial_comment="The response was too long for an inline message.",
-            )
-
-    except Exception as exc:
-        logger.exception("DeepSeek API call failed")
-        client.reactions_add(channel=channel, timestamp=message_ts, name="x")
-        say(text=f"DeepSeek API error: {exc}", thread_ts=thread_ts)
-
-    finally:
-        try:
-            client.reactions_remove(
-                channel=channel, timestamp=message_ts, name="eyes"
-            )
-        except Exception:
-            logger.warning("Failed to remove eyes reaction", exc_info=True)
-
-
-# ---------------------------------------------------------------------------
-# Entry point
-# ---------------------------------------------------------------------------
-if __name__ == "__main__":
-    logger.info("Starting DeepSeek Slack bot")
-    handler = SocketModeHandler(app, SLACK_APP_TOKEN)
-    handler.start()

deepseek/bot.py

@@ -0,0 +1,546 @@
+import json
+import os
+import re
+import sys
+import time
+import logging
+import asyncio
+
+import httpx
+from duckduckgo_search import DDGS
+from md2mrkdwn import convert as md_to_slack
+from slack_bolt.async_app import AsyncApp
+from slack_bolt.adapter.socket_mode.async_handler import AsyncSocketModeHandler
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s  %(levelname)-8s  %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+DEEPSEEK_TIMEOUT = 120  # seconds
+MAX_INLINE_LENGTH = 10_000  # characters
+
+def _has_code_snippet(text: str) -> bool:
+    """Return True if the text contains a fenced code block."""
+    return "```" in text
+
+MAX_TOOL_TURNS = 5  # max tool-call back-and-forths with DeepSeek
+
+# ---------------------------------------------------------------------------
+# Tool definitions (sent to DeepSeek API for function calling)
+# ---------------------------------------------------------------------------
+DEEPSEEK_TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "web_search",
+            "description": (
+                "Search the web for current, up-to-date information. "
+                "Returns a list of results with titles, URLs, and snippets. "
+                "Use this as a first step to find relevant pages."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "The search query string. Be specific and include relevant keywords.",
+                    }
+                },
+                "required": ["query"],
+                "additionalProperties": False,
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "web_fetch",
+            "description": (
+                "Fetch and read the full content of a web page. "
+                "Use this after web_search when you need details beyond the snippet — "
+                "for example, to read a full article, get specific numbers, "
+                "or understand context that the search snippet didn't cover."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {
+                        "type": "string",
+                        "description": "The full URL of the page to fetch.",
+                    }
+                },
+                "required": ["url"],
+                "additionalProperties": False,
+            },
+        },
+    },
+]
+
+# ---------------------------------------------------------------------------
+# Tool implementations
+# ---------------------------------------------------------------------------
+def _format_search_results(results: list[dict]) -> str:
+    """Format DuckDuckGo search results into a readable string."""
+    if not results:
+        return "No search results found."
+
+    lines = []
+    for i, r in enumerate(results[:5], 1):
+        title = r.get("title", "No title")
+        href = r.get("href", "")
+        body = r.get("body", "No description")
+        lines.append(f"{i}. {title}")
+        if href:
+            lines.append(f"   URL: {href}")
+        lines.append(f"   {body}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+async def execute_web_search(query: str) -> str:
+    """Execute a web search using DuckDuckGo and return formatted results."""
+    try:
+        results = await asyncio.to_thread(
+            lambda: list(DDGS().text(query, max_results=5))
+        )
+        return _format_search_results(results)
+    except Exception as exc:
+        logger.exception("Web search failed for query=%r", query)
+        return f"Web search error: {exc}"
+
+
+async def execute_web_fetch(url: str) -> str:
+    """Fetch a web page and return its body text."""
+    FETCH_TIMEOUT = 15
+    MAX_BODY_CHARS = 5000
+
+    try:
+        async with httpx.AsyncClient(timeout=FETCH_TIMEOUT, follow_redirects=True) as client:
+            response = await client.get(
+                url,
+                headers={"User-Agent": "Mozilla/5.0 (compatible; SlackBot/1.0)"},
+            )
+            response.raise_for_status()
+
+        content_type = response.headers.get("content-type", "")
+        if "text/html" not in content_type:
+            body = response.text
+        else:
+            try:
+                from lxml import html
+                doc = html.fromstring(response.content)
+                for tag in doc.xpath("//script | //style | //nav | //footer | //header"):
+                    tag.drop_tree()
+                body = doc.text_content()
+            except Exception:
+                body = response.text
+
+        lines = [line.strip() for line in body.splitlines() if line.strip()]
+        text = "\n".join(lines)
+
+        if len(text) > MAX_BODY_CHARS:
+            text = text[:MAX_BODY_CHARS] + "\n\n[truncated]"
+
+        return f"Content from {url}:\n\n{text}"
+
+    except httpx.TimeoutException:
+        return f"Error fetching {url}: request timed out"
+    except httpx.HTTPStatusError as exc:
+        return f"Error fetching {url}: HTTP {exc.response.status_code}"
+    except Exception as exc:
+        logger.exception("Web fetch failed for url=%r", url)
+        return f"Error fetching {url}: {exc}"
+
+
+# Registry mapping tool names to their async handler functions
+TOOL_EXECUTORS = {
+    "web_search": execute_web_search,
+    "web_fetch": execute_web_fetch,
+}
+
+# ---------------------------------------------------------------------------
+# DSML fallback parser — DeepSeek V4 sometimes leaks raw DSML markup in the
+# content field instead of returning structured tool_calls.
+# ---------------------------------------------------------------------------
+_DSML_INVOKE_RE = re.compile(
+    r'<｜｜DSML｜｜invoke\s+name="([^"]+)">'
+    r'(.*?)'
+    r'<｜｜DSML｜｜invoke>',
+    re.DOTALL,
+)
+_DSML_PARAM_RE = re.compile(
+    r'<｜｜DSML｜｜parameter\s+name="([^"]+)"[^>]*>'
+    r'(.*?)'
+    r'｜｜DSML｜｜parameter>',
+    re.DOTALL,
+)
+
+
+def parse_dsml_tool_calls(content: str) -> list[dict] | None:
+    """Parse raw DSML markup into structured tool_calls.
+
+    Returns a list of tool-call dicts compatible with the OpenAI/DeepSeek
+    tool_calls format, or None if no DSML was detected.
+    """
+    if "DSML" not in content:
+        return None
+
+    invocations = _DSML_INVOKE_RE.findall(content)
+    if not invocations:
+        return None
+
+    tool_calls = []
+    for i, (fn_name, param_block) in enumerate(invocations):
+        params = {}
+        for pname, pvalue in _DSML_PARAM_RE.findall(param_block):
+            params[pname] = pvalue.strip()
+        tool_calls.append({
+            "id": f"dsml_fallback_{i}",
+            "type": "function",
+            "function": {
+                "name": fn_name,
+                "arguments": json.dumps(params),
+            },
+        })
+
+    return tool_calls if tool_calls else None
+
+
+_DSML_BLOCK_RE = re.compile(
+    r'<｜｜DSML｜｜tool_calls>.*?<｜｜DSML｜｜tool_calls>',
+    re.DOTALL,
+)
+
+
+def _strip_dsml(text: str) -> str:
+    """Remove any leaked DSML tool-call blocks from text."""
+    if not text or "DSML" not in text:
+        return text
+    return _DSML_BLOCK_RE.sub("", text).strip()
+
+
+# ---------------------------------------------------------------------------
+# DeepSeek API client (async)
+# ---------------------------------------------------------------------------
+async def call_deepseek(
+    api_url: str,
+    api_key: str,
+    model: str,
+    messages: list[dict],
+    tools: list[dict] | None = None,
+) -> dict:
+    """Call the DeepSeek chat completions API asynchronously.
+
+    Returns the JSON-decoded response dict on success.
+    Raises httpx.HTTPStatusError on non-2xx responses.
+    """
+    payload: dict = {
+        "model": model,
+        "messages": messages,
+    }
+    if tools:
+        payload["tools"] = tools
+
+    async with httpx.AsyncClient(timeout=DEEPSEEK_TIMEOUT) as client:
+        response = await client.post(
+            api_url,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            json=payload,
+        )
+        response.raise_for_status()
+        return response.json()
+
+
+# ---------------------------------------------------------------------------
+# Tool calling loop
+# ---------------------------------------------------------------------------
+async def chat_with_tools(
+    api_url: str,
+    api_key: str,
+    model: str,
+    prompt_text: str,
+    ws_logger: logging.LoggerAdapter,
+) -> str:
+    """Send a prompt to DeepSeek with tool-calling support.
+
+    Handles the full tool-calling loop:
+      1. Send user message + tool definitions to DeepSeek
+      2. If DeepSeek responds with tool_calls, execute the requested tools
+      3. Send tool results back to DeepSeek
+      4. Repeat until DeepSeek produces a final answer or max turns reached
+
+    Returns the final reply text (or error message).
+    """
+    messages: list[dict] = [{"role": "user", "content": prompt_text}]
+
+    for turn in range(1, MAX_TOOL_TURNS + 1):
+        data = await call_deepseek(api_url, api_key, model, messages, DEEPSEEK_TOOLS)
+
+        choice = data["choices"][0]
+        finish_reason = choice["finish_reason"]
+        assistant_msg = choice["message"]
+
+        ws_logger.info(
+            "DeepSeek turn %d/%d  finish_reason=%s  tokens=%s",
+            turn,
+            MAX_TOOL_TURNS,
+            finish_reason,
+            data.get("usage", {}),
+        )
+
+        # Determine tool_calls: either from the structured response, or by
+        # parsing leaked DSML markup in the content field.
+        tool_calls = assistant_msg.get("tool_calls")
+        content = assistant_msg.get("content", "") or ""
+
+        if not tool_calls and finish_reason == "stop":
+            parsed = parse_dsml_tool_calls(content)
+            if parsed:
+                ws_logger.info(
+                    "Detected %d DSML tool call(s) in content (fallback parser)",
+                    len(parsed),
+                )
+                tool_calls = parsed
+                content = None
+                finish_reason = "tool_calls"
+
+        # When tool_calls are present, strip any DSML that leaked into content
+        if tool_calls and content and "DSML" in content:
+            ws_logger.info("Stripping leaked DSML from assistant content")
+            content = None
+
+        # Build stored message for round-tripping back to the API
+        stored_msg: dict = {"role": "assistant"}
+        if assistant_msg.get("reasoning_content") is not None:
+            stored_msg["reasoning_content"] = assistant_msg["reasoning_content"]
+        elif "reasoning_content" in assistant_msg:
+            stored_msg["reasoning_content"] = ""
+        if content:
+            stored_msg["content"] = content
+        if tool_calls:
+            stored_msg["tool_calls"] = tool_calls
+
+        messages.append(stored_msg)
+
+        if finish_reason == "tool_calls" and tool_calls:
+            ws_logger.info("DeepSeek requested %d tool call(s)", len(tool_calls))
+
+            for tc in tool_calls:
+                fn_name = tc["function"]["name"]
+                fn_args = json.loads(tc["function"]["arguments"])
+                ws_logger.info(
+                    "Executing tool: %s(%s)", fn_name, json.dumps(fn_args)
+                )
+
+                executor = TOOL_EXECUTORS.get(fn_name)
+                if executor:
+                    try:
+                        result = await executor(**fn_args)
+                    except Exception as tool_exc:
+                        result = f"Tool execution error: {tool_exc}"
+                        ws_logger.exception("Tool %s failed", fn_name)
+                else:
+                    result = f"Error: Unknown tool '{fn_name}'"
+                    ws_logger.warning("Unknown tool requested: %s", fn_name)
+
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": tc["id"],
+                    "content": result,
+                })
+
+            continue
+
+        elif finish_reason == "stop":
+            return _strip_dsml(content)
+
+        else:
+            ws_logger.warning("Unexpected finish_reason: %s", finish_reason)
+            return _strip_dsml(content)
+
+    # Tool turns exhausted — make one final call without tool definitions so
+    # DeepSeek is forced to produce a textual answer from the results collected.
+    ws_logger.info("Tool turns exhausted; making final call without tools")
+    messages.append({
+        "role": "user",
+        "content": (
+            "Please provide your answer now based on the tool results above. "
+            "Do not attempt any more tool calls. Summarize what you found."
+        ),
+    })
+    data = await call_deepseek(api_url, api_key, model, messages, tools=None)
+    final = data["choices"][0]["message"].get("content", "") or ""
+    final = _strip_dsml(final)
+    return final or (
+        "I wasn't able to complete the request within the allowed number of steps. "
+        "Please try again or simplify your question."
+    )
+
+
+# ---------------------------------------------------------------------------
+# Load workspace configs
+# ---------------------------------------------------------------------------
+def load_workspaces():
+    raw = os.environ.get("DEEPSEEK_WORKSPACES")
+    if raw:
+        workspaces = json.loads(raw)
+    else:
+        slack_bot_token = os.environ.get("SLACK_BOT_TOKEN")
+        slack_app_token = os.environ.get("SLACK_APP_TOKEN")
+        deepseek_api_key = os.environ.get("DEEPSEEK_API_KEY")
+        missing = [
+            name
+            for name, val in [
+                ("SLACK_BOT_TOKEN", slack_bot_token),
+                ("SLACK_APP_TOKEN", slack_app_token),
+                ("DEEPSEEK_API_KEY", deepseek_api_key),
+            ]
+            if not val
+        ]
+        if missing:
+            sys.exit(
+                f"ERROR: Set DEEPSEEK_WORKSPACES (JSON) or provide legacy env vars. "
+                f"Missing: {', '.join(missing)}"
+            )
+        workspaces = [
+            {
+                "name": "default",
+                "slack_bot_token": slack_bot_token,
+                "slack_app_token": slack_app_token,
+                "deepseek_api_key": deepseek_api_key,
+            }
+        ]
+
+    required_keys = {"name", "slack_bot_token", "slack_app_token", "deepseek_api_key"}
+    for i, ws in enumerate(workspaces):
+        missing = required_keys - set(ws.keys())
+        if missing:
+            sys.exit(
+                f"ERROR: Workspace entry {i} is missing keys: {', '.join(sorted(missing))}"
+            )
+
+    return workspaces
+
+
+# ---------------------------------------------------------------------------
+# Build an async Slack app for one workspace
+# ---------------------------------------------------------------------------
+def make_app(ws):
+    ws_name = ws["name"]
+    deepseek_api_key = ws["deepseek_api_key"]
+    deepseek_api_url = ws.get("deepseek_api_url", "https://api.deepseek.com/chat/completions")
+    deepseek_model = ws.get("deepseek_model", "deepseek-v4-pro")
+
+    ws_logger = logging.LoggerAdapter(logger, {"workspace": ws_name})
+
+    slack_app = AsyncApp(token=ws["slack_bot_token"])
+
+    @slack_app.event("app_mention")
+    async def handle_mention(event, client, say):
+        channel = event["channel"]
+        message_ts = event["ts"]
+        thread_ts = event.get("thread_ts") or message_ts
+        raw_text = event.get("text", "")
+
+        prompt_text = re.sub(r"<@[A-Z0-9]+>", "", raw_text).strip()
+
+        ws_logger.info("Mention received  channel=%s  ts=%s", channel, message_ts)
+        ws_logger.info("Prompt: %.200r", prompt_text)
+
+        if not prompt_text:
+            ws_logger.info("Empty prompt -- skipping API call")
+            await say(
+                text=(
+                    "You mentioned me but didn't include any prompt text, "
+                    "so I didn't make an API call. "
+                    "Try again with a question or message after the mention."
+                ),
+                thread_ts=thread_ts,
+            )
+            return
+
+        await client.reactions_add(channel=channel, timestamp=message_ts, name="eyes")
+
+        try:
+            ws_logger.info("DeepSeek API call starting  model=%s", deepseek_model)
+            start = time.time()
+
+            reply_text = await chat_with_tools(
+                deepseek_api_url,
+                deepseek_api_key,
+                deepseek_model,
+                prompt_text,
+                ws_logger,
+            )
+
+            duration = time.time() - start
+            ws_logger.info(
+                "DeepSeek API call completed  duration=%.2fs  chars=%d",
+                duration,
+                len(reply_text),
+            )
+
+            reply_text = md_to_slack(reply_text)
+
+            if len(reply_text) <= MAX_INLINE_LENGTH and not _has_code_snippet(reply_text):
+                await say(text=reply_text, thread_ts=thread_ts)
+            else:
+                initial_comment = (
+                    "The response contains a code snippet, which doesn't render well inline."
+                    if _has_code_snippet(reply_text)
+                    else "The response was too long for an inline message."
+                )
+                await client.files_upload_v2(
+                    channel=channel,
+                    thread_ts=thread_ts,
+                    content=reply_text,
+                    filename="response.txt",
+                    title="DeepSeek Response",
+                    initial_comment=initial_comment,
+                )
+
+        except Exception as exc:
+            ws_logger.exception("DeepSeek API call failed")
+            await client.reactions_add(channel=channel, timestamp=message_ts, name="x")
+            await say(text=f"DeepSeek API error: {exc}", thread_ts=thread_ts)
+
+        finally:
+            try:
+                await client.reactions_remove(
+                    channel=channel, timestamp=message_ts, name="eyes"
+                )
+            except Exception:
+                ws_logger.warning("Failed to remove eyes reaction", exc_info=True)
+
+    return slack_app
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+async def main():
+    workspaces = load_workspaces()
+    logger.info("Starting DeepSeek bot for %d workspace(s)", len(workspaces))
+
+    handlers = []
+    for ws in workspaces:
+        slack_app = make_app(ws)
+        handler = AsyncSocketModeHandler(slack_app, ws["slack_app_token"])
+        handlers.append(handler.start_async())
+
+    await asyncio.gather(*handlers)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

deepseek/requirements.txt

@@ -0,0 +1,6 @@
+slack-bolt>=1.28.0
+aiohttp>=3.9.0
+httpx>=0.28.1
+md2mrkdwn>=0.4.3
+duckduckgo-search>=8.0.0
+lxml>=5.0.0

docker-compose.yml

@@ -1,5 +1,61 @@
 services:
-  bot:
-    build: .
+  deepseek-bot:
+    build:
+      context: .
+      args:
+        APP: deepseek
     env_file: .env
     restart: unless-stopped
+
+  bender-bot:
+    build:
+      context: .
+      args:
+        APP: bender
+    env_file: .env
+    restart: unless-stopped
+
+  kimi-bot:
+    build:
+      context: .
+      args:
+        APP: kimi
+    env_file: .env
+    restart: unless-stopped
+
+  minimax-bot:
+    build:
+      context: .
+      args:
+        APP: minimax
+    env_file: .env
+    restart: unless-stopped
+
+  mediawiki-mcp:
+    image: ghcr.io/professionalwiki/mediawiki-mcp-server
+    env_file: .env
+    environment:
+      CONFIG: /config/config.json
+      MCP_TRANSPORT: http
+      MCP_BIND: 0.0.0.0
+      MCP_LOG_LEVEL: info
+      MCP_ALLOW_STATIC_FALLBACK: "true"
+      WIKI_CHARLESREID1_URL: ${WIKI_CHARLESREID1_URL}
+      WIKI_CHARLESREID1_BOT_USER: ${WIKI_CHARLESREID1_BOT_USER}
+      WIKI_CHARLESREID1_BOT_PASS: ${WIKI_CHARLESREID1_BOT_PASS}
+    volumes:
+      - ./mediawiki-mcp-config.json:/config/config.json:ro
+    restart: unless-stopped
+
+  wiki-charlesreid1-bot:
+    build:
+      context: .
+      args:
+        APP: wiki-charlesreid1
+    env_file: .env
+    environment:
+      MCP_SERVER_URL: http://mediawiki-mcp:8080/mcp
+      WIKI_CHARLESREID1_WORKSPACES: ${WIKI_CHARLESREID1_WORKSPACES}
+    depends_on:
+      - mediawiki-mcp
+    restart: unless-stopped

kimi/bot.py

@@ -0,0 +1,193 @@
+import json
+import os
+import re
+import sys
+import time
+import logging
+import threading
+
+import requests
+from md2mrkdwn import convert as md_to_slack
+from slack_bolt import App
+from slack_bolt.adapter.socket_mode import SocketModeHandler
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s  %(levelname)-8s  %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+KIMI_TIMEOUT = 120  # seconds
+MAX_INLINE_LENGTH = 2800  # characters
+
+
+# ---------------------------------------------------------------------------
+# Load workspace configs
+# ---------------------------------------------------------------------------
+def load_workspaces():
+    raw = os.environ.get("KIMI_WORKSPACES")
+    if raw:
+        workspaces = json.loads(raw)
+    else:
+        slack_bot_token = os.environ.get("SLACK_BOT_TOKEN_KIMI")
+        slack_app_token = os.environ.get("SLACK_APP_TOKEN_KIMI")
+        kimi_api_key = os.environ.get("KIMI_API_KEY")
+        missing = [
+            name
+            for name, val in [
+                ("SLACK_BOT_TOKEN_KIMI", slack_bot_token),
+                ("SLACK_APP_TOKEN_KIMI", slack_app_token),
+                ("KIMI_API_KEY", kimi_api_key),
+            ]
+            if not val
+        ]
+        if missing:
+            sys.exit(
+                f"ERROR: Set KIMI_WORKSPACES (JSON) or provide legacy env vars. "
+                f"Missing: {', '.join(missing)}"
+            )
+        workspaces = [
+            {
+                "name": "default",
+                "slack_bot_token": slack_bot_token,
+                "slack_app_token": slack_app_token,
+                "kimi_api_key": kimi_api_key,
+            }
+        ]
+
+    required_keys = {"name", "slack_bot_token", "slack_app_token", "kimi_api_key"}
+    for i, ws in enumerate(workspaces):
+        missing = required_keys - set(ws.keys())
+        if missing:
+            sys.exit(
+                f"ERROR: Workspace entry {i} is missing keys: {', '.join(sorted(missing))}"
+            )
+
+    return workspaces
+
+
+# ---------------------------------------------------------------------------
+# Build a Slack app for one workspace
+# ---------------------------------------------------------------------------
+def make_app(ws):
+    ws_name = ws["name"]
+    kimi_api_key = ws["kimi_api_key"]
+    kimi_api_url = ws.get("kimi_api_url", "https://opencode.ai/zen/go/v1/chat/completions")
+    kimi_model = ws.get("kimi_model", "kimi-k2.6")
+
+    ws_logger = logging.LoggerAdapter(logger, {"workspace": ws_name})
+
+    slack_app = App(token=ws["slack_bot_token"])
+
+    @slack_app.event("app_mention")
+    def handle_mention(event, client, say):
+        channel = event["channel"]
+        message_ts = event["ts"]
+        thread_ts = event.get("thread_ts") or message_ts
+        raw_text = event.get("text", "")
+
+        prompt_text = re.sub(r"<@[A-Z0-9]+>", "", raw_text).strip()
+
+        ws_logger.info("Mention received  channel=%s  ts=%s", channel, message_ts)
+        ws_logger.info("Prompt: %.200r", prompt_text)
+
+        if not prompt_text:
+            ws_logger.info("Empty prompt -- skipping API call")
+            say(
+                text=(
+                    "You mentioned me but didn't include any prompt text, "
+                    "so I didn't make an API call. "
+                    "Try again with a question or message after the mention."
+                ),
+                thread_ts=thread_ts,
+            )
+            return
+
+        client.reactions_add(channel=channel, timestamp=message_ts, name="eyes")
+
+        try:
+            ws_logger.info("Kimi API call starting  model=%s", kimi_model)
+            start = time.time()
+
+            response = requests.post(
+                kimi_api_url,
+                headers={
+                    "Authorization": f"Bearer {kimi_api_key}",
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "model": kimi_model,
+                    "messages": [{"role": "user", "content": prompt_text}],
+                },
+                timeout=KIMI_TIMEOUT,
+            )
+
+            duration = time.time() - start
+            ws_logger.info(
+                "Kimi API call completed  status=%s  duration=%.2fs",
+                response.status_code,
+                duration,
+            )
+
+            response.raise_for_status()
+            data = response.json()
+            reply_text = data["choices"][0]["message"]["content"]
+            reply_text = md_to_slack(reply_text)
+
+            if len(reply_text) <= MAX_INLINE_LENGTH:
+                say(text=reply_text, thread_ts=thread_ts)
+            else:
+                client.files_upload_v2(
+                    channel=channel,
+                    thread_ts=thread_ts,
+                    content=reply_text,
+                    filename="response.txt",
+                    title="Kimi Response",
+                    initial_comment="The response was too long for an inline message.",
+                )
+
+        except Exception as exc:
+            ws_logger.exception("Kimi API call failed")
+            client.reactions_add(channel=channel, timestamp=message_ts, name="x")
+            say(text=f"Kimi API error: {exc}", thread_ts=thread_ts)
+
+        finally:
+            try:
+                client.reactions_remove(
+                    channel=channel, timestamp=message_ts, name="eyes"
+                )
+            except Exception:
+                ws_logger.warning("Failed to remove eyes reaction", exc_info=True)
+
+    return slack_app
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+if __name__ == "__main__":
+    workspaces = load_workspaces()
+    logger.info("Starting Kimi bot for %d workspace(s)", len(workspaces))
+
+    handlers = []
+    for ws in workspaces:
+        slack_app = make_app(ws)
+        handler = SocketModeHandler(slack_app, ws["slack_app_token"])
+        handlers.append((ws["name"], handler))
+
+    for ws_name, handler in handlers[:-1]:
+        logger.info("Starting workspace %r in background thread", ws_name)
+        thread = threading.Thread(
+            target=handler.start, name=f"kimi-{ws_name}", daemon=True
+        )
+        thread.start()
+
+    last_name, last_handler = handlers[-1]
+    logger.info("Starting workspace %r in foreground", last_name)
+    last_handler.start()

kimi/requirements.txt

@@ -0,0 +1,3 @@
+slack-bolt>=1.28.0
+requests>=2.31.0
+md2mrkdwn>=0.4.3

mediawiki-mcp-config.json

@@ -0,0 +1,16 @@
+{
+  "wikis": {
+    "charlesreid1": {
+      "server": "${WIKI_CHARLESREID1_URL}",
+      "scriptpath": "/w",
+      "articlepath": "/wiki",
+      "credentials": {
+        "botPassword": {
+          "username": "${WIKI_CHARLESREID1_BOT_USER}",
+          "password": "${WIKI_CHARLESREID1_BOT_PASS}"
+        }
+      }
+    }
+  },
+  "defaultWiki": "charlesreid1"
+}

minimax/bot.py

@@ -0,0 +1,193 @@
+import json
+import os
+import re
+import sys
+import time
+import logging
+import threading
+
+import requests
+from md2mrkdwn import convert as md_to_slack
+from slack_bolt import App
+from slack_bolt.adapter.socket_mode import SocketModeHandler
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s  %(levelname)-8s  %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+MINIMAX_TIMEOUT = 120  # seconds
+MAX_INLINE_LENGTH = 2800  # characters
+
+
+# ---------------------------------------------------------------------------
+# Load workspace configs
+# ---------------------------------------------------------------------------
+def load_workspaces():
+    raw = os.environ.get("MINIMAX_WORKSPACES")
+    if raw:
+        workspaces = json.loads(raw)
+    else:
+        slack_bot_token = os.environ.get("SLACK_BOT_TOKEN_MINIMAX")
+        slack_app_token = os.environ.get("SLACK_APP_TOKEN_MINIMAX")
+        minimax_api_key = os.environ.get("MINIMAX_API_KEY")
+        missing = [
+            name
+            for name, val in [
+                ("SLACK_BOT_TOKEN_MINIMAX", slack_bot_token),
+                ("SLACK_APP_TOKEN_MINIMAX", slack_app_token),
+                ("MINIMAX_API_KEY", minimax_api_key),
+            ]
+            if not val
+        ]
+        if missing:
+            sys.exit(
+                f"ERROR: Set MINIMAX_WORKSPACES (JSON) or provide legacy env vars. "
+                f"Missing: {', '.join(missing)}"
+            )
+        workspaces = [
+            {
+                "name": "default",
+                "slack_bot_token": slack_bot_token,
+                "slack_app_token": slack_app_token,
+                "minimax_api_key": minimax_api_key,
+            }
+        ]
+
+    required_keys = {"name", "slack_bot_token", "slack_app_token", "minimax_api_key"}
+    for i, ws in enumerate(workspaces):
+        missing = required_keys - set(ws.keys())
+        if missing:
+            sys.exit(
+                f"ERROR: Workspace entry {i} is missing keys: {', '.join(sorted(missing))}"
+            )
+
+    return workspaces
+
+
+# ---------------------------------------------------------------------------
+# Build a Slack app for one workspace
+# ---------------------------------------------------------------------------
+def make_app(ws):
+    ws_name = ws["name"]
+    minimax_api_key = ws["minimax_api_key"]
+    minimax_api_url = ws.get("minimax_api_url", "https://opencode.ai/zen/go/v1/chat/completions")
+    minimax_model = ws.get("minimax_model", "minimax-m2.7")
+
+    ws_logger = logging.LoggerAdapter(logger, {"workspace": ws_name})
+
+    slack_app = App(token=ws["slack_bot_token"])
+
+    @slack_app.event("app_mention")
+    def handle_mention(event, client, say):
+        channel = event["channel"]
+        message_ts = event["ts"]
+        thread_ts = event.get("thread_ts") or message_ts
+        raw_text = event.get("text", "")
+
+        prompt_text = re.sub(r"<@[A-Z0-9]+>", "", raw_text).strip()
+
+        ws_logger.info("Mention received  channel=%s  ts=%s", channel, message_ts)
+        ws_logger.info("Prompt: %.200r", prompt_text)
+
+        if not prompt_text:
+            ws_logger.info("Empty prompt -- skipping API call")
+            say(
+                text=(
+                    "You mentioned me but didn't include any prompt text, "
+                    "so I didn't make an API call. "
+                    "Try again with a question or message after the mention."
+                ),
+                thread_ts=thread_ts,
+            )
+            return
+
+        client.reactions_add(channel=channel, timestamp=message_ts, name="eyes")
+
+        try:
+            ws_logger.info("MiniMax API call starting  model=%s", minimax_model)
+            start = time.time()
+
+            response = requests.post(
+                minimax_api_url,
+                headers={
+                    "Authorization": f"Bearer {minimax_api_key}",
+                    "Content-Type": "application/json",
+                },
+                json={
+                    "model": minimax_model,
+                    "messages": [{"role": "user", "content": prompt_text}],
+                },
+                timeout=MINIMAX_TIMEOUT,
+            )
+
+            duration = time.time() - start
+            ws_logger.info(
+                "MiniMax API call completed  status=%s  duration=%.2fs",
+                response.status_code,
+                duration,
+            )
+
+            response.raise_for_status()
+            data = response.json()
+            reply_text = data["choices"][0]["message"]["content"]
+            reply_text = md_to_slack(reply_text)
+
+            if len(reply_text) <= MAX_INLINE_LENGTH:
+                say(text=reply_text, thread_ts=thread_ts)
+            else:
+                client.files_upload_v2(
+                    channel=channel,
+                    thread_ts=thread_ts,
+                    content=reply_text,
+                    filename="response.txt",
+                    title="MiniMax Response",
+                    initial_comment="The response was too long for an inline message.",
+                )
+
+        except Exception as exc:
+            ws_logger.exception("MiniMax API call failed")
+            client.reactions_add(channel=channel, timestamp=message_ts, name="x")
+            say(text=f"MiniMax API error: {exc}", thread_ts=thread_ts)
+
+        finally:
+            try:
+                client.reactions_remove(
+                    channel=channel, timestamp=message_ts, name="eyes"
+                )
+            except Exception:
+                ws_logger.warning("Failed to remove eyes reaction", exc_info=True)
+
+    return slack_app
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+if __name__ == "__main__":
+    workspaces = load_workspaces()
+    logger.info("Starting MiniMax bot for %d workspace(s)", len(workspaces))
+
+    handlers = []
+    for ws in workspaces:
+        slack_app = make_app(ws)
+        handler = SocketModeHandler(slack_app, ws["slack_app_token"])
+        handlers.append((ws["name"], handler))
+
+    for ws_name, handler in handlers[:-1]:
+        logger.info("Starting workspace %r in background thread", ws_name)
+        thread = threading.Thread(
+            target=handler.start, name=f"minimax-{ws_name}", daemon=True
+        )
+        thread.start()
+
+    last_name, last_handler = handlers[-1]
+    logger.info("Starting workspace %r in foreground", last_name)
+    last_handler.start()

minimax/requirements.txt

@@ -0,0 +1,3 @@
+slack-bolt>=1.28.0
+requests>=2.31.0
+md2mrkdwn>=0.4.3

requirements.txt

@@ -1,2 +0,0 @@
-slack-bolt==1.28.0
-requests==2.33.1

wiki-charlesreid1/bot.py

@@ -0,0 +1,611 @@
+import json
+import os
+import re
+import sys
+import time
+import logging
+import asyncio
+
+import httpx
+from duckduckgo_search import DDGS
+from md2mrkdwn import convert as md_to_slack
+from slack_bolt.async_app import AsyncApp
+from slack_bolt.adapter.socket_mode.async_handler import AsyncSocketModeHandler
+from mcp.client.session import ClientSession
+from mcp.client.streamable_http import streamablehttp_client
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s  %(levelname)-8s  %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+DEEPSEEK_TIMEOUT = 120  # seconds
+MAX_INLINE_LENGTH = 2800  # characters
+MAX_TOOL_TURNS = 5  # max tool-call back-and-forths with DeepSeek
+
+# ---------------------------------------------------------------------------
+# Tool definitions (sent to DeepSeek API for function calling)
+# ---------------------------------------------------------------------------
+DEEPSEEK_TOOLS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "web_search",
+            "description": (
+                "Search the web for current, up-to-date information. "
+                "Returns a list of results with titles, URLs, and snippets. "
+                "Use this as a first step to find relevant pages."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "query": {
+                        "type": "string",
+                        "description": "The search query string. Be specific and include relevant keywords.",
+                    }
+                },
+                "required": ["query"],
+                "additionalProperties": False,
+            },
+        },
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "web_fetch",
+            "description": (
+                "Fetch and read the full content of a web page. "
+                "Use this after web_search when you need details beyond the snippet — "
+                "for example, to read a full article, get specific numbers, "
+                "or understand context that the search snippet didn't cover."
+            ),
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "url": {
+                        "type": "string",
+                        "description": "The full URL of the page to fetch.",
+                    }
+                },
+                "required": ["url"],
+                "additionalProperties": False,
+            },
+        },
+    },
+]
+
+# ---------------------------------------------------------------------------
+# Tool implementations
+# ---------------------------------------------------------------------------
+def _format_search_results(results: list[dict]) -> str:
+    """Format DuckDuckGo search results into a readable string."""
+    if not results:
+        return "No search results found."
+
+    lines = []
+    for i, r in enumerate(results[:5], 1):
+        title = r.get("title", "No title")
+        href = r.get("href", "")
+        body = r.get("body", "No description")
+        lines.append(f"{i}. {title}")
+        if href:
+            lines.append(f"   URL: {href}")
+        lines.append(f"   {body}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+async def execute_web_search(query: str) -> str:
+    """Execute a web search using DuckDuckGo and return formatted results."""
+    try:
+        results = await asyncio.to_thread(
+            lambda: list(DDGS().text(query, max_results=5))
+        )
+        return _format_search_results(results)
+    except Exception as exc:
+        logger.exception("Web search failed for query=%r", query)
+        return f"Web search error: {exc}"
+
+
+async def execute_web_fetch(url: str) -> str:
+    """Fetch a web page and return its body text."""
+    FETCH_TIMEOUT = 15
+    MAX_BODY_CHARS = 5000
+
+    try:
+        async with httpx.AsyncClient(timeout=FETCH_TIMEOUT, follow_redirects=True) as client:
+            response = await client.get(
+                url,
+                headers={"User-Agent": "Mozilla/5.0 (compatible; SlackBot/1.0)"},
+            )
+            response.raise_for_status()
+
+        content_type = response.headers.get("content-type", "")
+        if "text/html" not in content_type:
+            body = response.text
+        else:
+            try:
+                from lxml import html
+                doc = html.fromstring(response.content)
+                for tag in doc.xpath("//script | //style | //nav | //footer | //header"):
+                    tag.drop_tree()
+                body = doc.text_content()
+            except Exception:
+                body = response.text
+
+        lines = [line.strip() for line in body.splitlines() if line.strip()]
+        text = "\n".join(lines)
+
+        if len(text) > MAX_BODY_CHARS:
+            text = text[:MAX_BODY_CHARS] + "\n\n[truncated]"
+
+        return f"Content from {url}:\n\n{text}"
+
+    except httpx.TimeoutException:
+        return f"Error fetching {url}: request timed out"
+    except httpx.HTTPStatusError as exc:
+        return f"Error fetching {url}: HTTP {exc.response.status_code}"
+    except Exception as exc:
+        logger.exception("Web fetch failed for url=%r", url)
+        return f"Error fetching {url}: {exc}"
+
+
+# Registry mapping tool names to their async handler functions
+TOOL_EXECUTORS = {
+    "web_search": execute_web_search,
+    "web_fetch": execute_web_fetch,
+}
+
+# ---------------------------------------------------------------------------
+# DSML fallback parser — DeepSeek V4 sometimes leaks raw DSML markup in the
+# content field instead of returning structured tool_calls.
+# ---------------------------------------------------------------------------
+_DSML_INVOKE_RE = re.compile(
+    r'<｜｜DSML｜｜dsml_invoke\s+name="([^"]+)">'
+    r'(.*?)'
+    r'<｜｜DSML｜｜dsml_invoke>',
+    re.DOTALL,
+)
+_DSML_PARAM_RE = re.compile(
+    r'<｜｜DSML｜｜dsml_parameter\s+name="([^"]+)"[^>]*>'
+    r'(.*?)'
+    r'<｜｜DSML｜｜dsml_parameter>',
+    re.DOTALL,
+)
+
+
+def parse_dsml_tool_calls(content: str) -> list[dict] | None:
+    """Parse raw DSML markup into structured tool_calls.
+
+    Returns a list of tool-call dicts compatible with the OpenAI/DeepSeek
+    tool_calls format, or None if no DSML was detected.
+    """
+    if "DSML" not in content:
+        return None
+
+    invocations = _DSML_INVOKE_RE.findall(content)
+    if not invocations:
+        return None
+
+    tool_calls = []
+    for i, (fn_name, param_block) in enumerate(invocations):
+        params = {}
+        for pname, pvalue in _DSML_PARAM_RE.findall(param_block):
+            params[pname] = pvalue.strip()
+        tool_calls.append({
+            "id": f"dsml_fallback_{i}",
+            "type": "function",
+            "function": {
+                "name": fn_name,
+                "arguments": json.dumps(params),
+            },
+        })
+
+    return tool_calls if tool_calls else None
+
+
+_DSML_BLOCK_RE = re.compile(
+    r'<｜｜DSML｜｜dsml_tool_calls>.*?<｜｜DSML｜｜dsml_tool_calls>',
+    re.DOTALL,
+)
+
+
+def _strip_dsml(text: str) -> str:
+    """Remove any leaked DSML tool-call blocks from text."""
+    if not text or "DSML" not in text:
+        return text
+    return _DSML_BLOCK_RE.sub("", text).strip()
+
+
+# ---------------------------------------------------------------------------
+# MCP client — connects to the MediaWiki MCP server sidecar
+# ---------------------------------------------------------------------------
+async def mcp_tools_to_deepseek(tools) -> list[dict]:
+    """Convert MCP tool definitions to DeepSeek function-calling schema."""
+    result = []
+    for tool in tools:
+        result.append({
+            "type": "function",
+            "function": {
+                "name": tool.name,
+                "description": tool.description or "",
+                "parameters": tool.inputSchema,
+            },
+        })
+    return result
+
+
+async def execute_mcp_tool(session: ClientSession, name: str, args: dict) -> str:
+    """Call a tool on the MCP server and return text content from the result."""
+    result = await session.call_tool(name, args)
+    parts = []
+    for block in result.content:
+        if hasattr(block, "text"):
+            parts.append(block.text)
+        else:
+            parts.append(str(block))
+    return "\n".join(parts)
+
+
+async def connect_mcp(url: str):
+    """Connect to the MediaWiki MCP server, initialize, and discover tools.
+
+    Returns (context_manager, session, deepseek_tools).
+    The caller must keep the context_manager alive for the session to work,
+    and call ``await context_manager.__aexit__(None, None, None)`` on shutdown.
+    """
+    context = streamablehttp_client(url)
+    read, write, _ = await context.__aenter__()
+    session = ClientSession(read, write)
+    await session.initialize()
+    tools_result = await session.list_tools()
+    logger.info("Discovered %d tools from MCP server at %s", len(tools_result.tools), url)
+    for t in tools_result.tools:
+        logger.info("  MCP tool: %s", t.name)
+    deepseek_tools = await mcp_tools_to_deepseek(tools_result.tools)
+    return context, session, deepseek_tools
+
+
+# ---------------------------------------------------------------------------
+# DeepSeek API client (async)
+# ---------------------------------------------------------------------------
+async def call_deepseek(
+    api_url: str,
+    api_key: str,
+    model: str,
+    messages: list[dict],
+    tools: list[dict] | None = None,
+) -> dict:
+    """Call the DeepSeek chat completions API asynchronously.
+
+    Returns the JSON-decoded response dict on success.
+    Raises httpx.HTTPStatusError on non-2xx responses.
+    """
+    payload: dict = {
+        "model": model,
+        "messages": messages,
+    }
+    if tools:
+        payload["tools"] = tools
+
+    async with httpx.AsyncClient(timeout=DEEPSEEK_TIMEOUT) as client:
+        response = await client.post(
+            api_url,
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+            },
+            json=payload,
+        )
+        response.raise_for_status()
+        return response.json()
+
+
+# ---------------------------------------------------------------------------
+# Tool calling loop
+# ---------------------------------------------------------------------------
+async def chat_with_tools(
+    api_url: str,
+    api_key: str,
+    model: str,
+    prompt_text: str,
+    ws_logger: logging.LoggerAdapter,
+    mcp_session: ClientSession | None,
+    all_tools: list[dict],
+) -> str:
+    """Send a prompt to DeepSeek with tool-calling support.
+
+    Handles the full tool-calling loop:
+      1. Send user message + tool definitions to DeepSeek
+      2. If DeepSeek responds with tool_calls, execute the requested tools
+      3. Send tool results back to DeepSeek
+      4. Repeat until DeepSeek produces a final answer or max turns reached
+
+    Returns the final reply text (or error message).
+    """
+    messages: list[dict] = [{"role": "user", "content": prompt_text}]
+
+    for turn in range(1, MAX_TOOL_TURNS + 1):
+        data = await call_deepseek(api_url, api_key, model, messages, all_tools)
+
+        choice = data["choices"][0]
+        finish_reason = choice["finish_reason"]
+        assistant_msg = choice["message"]
+
+        ws_logger.info(
+            "DeepSeek turn %d/%d  finish_reason=%s  tokens=%s",
+            turn,
+            MAX_TOOL_TURNS,
+            finish_reason,
+            data.get("usage", {}),
+        )
+
+        # Determine tool_calls: either from the structured response, or by
+        # parsing leaked DSML markup in the content field.
+        tool_calls = assistant_msg.get("tool_calls")
+        content = assistant_msg.get("content", "") or ""
+
+        if not tool_calls and finish_reason == "stop":
+            parsed = parse_dsml_tool_calls(content)
+            if parsed:
+                ws_logger.info(
+                    "Detected %d DSML tool call(s) in content (fallback parser)",
+                    len(parsed),
+                )
+                tool_calls = parsed
+                content = None
+                finish_reason = "tool_calls"
+
+        # When tool_calls are present, strip any DSML that leaked into content
+        if tool_calls and content and "DSML" in content:
+            ws_logger.info("Stripping leaked DSML from assistant content")
+            content = None
+
+        # Build stored message for round-tripping back to the API
+        stored_msg: dict = {"role": "assistant"}
+        if assistant_msg.get("reasoning_content") is not None:
+            stored_msg["reasoning_content"] = assistant_msg["reasoning_content"]
+        elif "reasoning_content" in assistant_msg:
+            stored_msg["reasoning_content"] = ""
+        if content:
+            stored_msg["content"] = content
+        if tool_calls:
+            stored_msg["tool_calls"] = tool_calls
+
+        messages.append(stored_msg)
+
+        if finish_reason == "tool_calls" and tool_calls:
+            ws_logger.info("DeepSeek requested %d tool call(s)", len(tool_calls))
+
+            for tc in tool_calls:
+                fn_name = tc["function"]["name"]
+                fn_args = json.loads(tc["function"]["arguments"])
+                ws_logger.info(
+                    "Executing tool: %s(%s)", fn_name, json.dumps(fn_args)
+                )
+
+                executor = TOOL_EXECUTORS.get(fn_name)
+                if executor:
+                    try:
+                        result = await executor(**fn_args)
+                    except Exception as tool_exc:
+                        result = f"Tool execution error: {tool_exc}"
+                        ws_logger.exception("Tool %s failed", fn_name)
+                elif mcp_session is not None:
+                    try:
+                        result = await execute_mcp_tool(mcp_session, fn_name, fn_args)
+                    except Exception as tool_exc:
+                        result = f"MediaWiki tool error: {tool_exc}"
+                        ws_logger.exception("MCP tool %s failed", fn_name)
+                else:
+                    result = f"Error: Unknown tool '{fn_name}'"
+                    ws_logger.warning("Unknown tool requested: %s", fn_name)
+
+                messages.append({
+                    "role": "tool",
+                    "tool_call_id": tc["id"],
+                    "content": result,
+                })
+
+            continue
+
+        elif finish_reason == "stop":
+            return _strip_dsml(content)
+
+        else:
+            ws_logger.warning("Unexpected finish_reason: %s", finish_reason)
+            return _strip_dsml(content)
+
+    # Tool turns exhausted — make one final call without tool definitions so
+    # DeepSeek is forced to produce a textual answer from the results collected.
+    ws_logger.info("Tool turns exhausted; making final call without tools")
+    messages.append({
+        "role": "user",
+        "content": (
+            "Please provide your answer now based on the tool results above. "
+            "Do not attempt any more tool calls. Summarize what you found."
+        ),
+    })
+    data = await call_deepseek(api_url, api_key, model, messages, tools=None)
+    final = data["choices"][0]["message"].get("content", "") or ""
+    final = _strip_dsml(final)
+    return final or (
+        "I wasn't able to complete the request within the allowed number of steps. "
+        "Please try again or simplify your question."
+    )
+
+
+# ---------------------------------------------------------------------------
+# Load workspace configs
+# ---------------------------------------------------------------------------
+def load_workspaces():
+    raw = os.environ.get("WIKI_CHARLESREID1_WORKSPACES")
+    if raw:
+        workspaces = json.loads(raw)
+    else:
+        slack_bot_token = os.environ.get("SLACK_BOT_TOKEN")
+        slack_app_token = os.environ.get("SLACK_APP_TOKEN")
+        deepseek_api_key = os.environ.get("DEEPSEEK_API_KEY")
+        missing = [
+            name
+            for name, val in [
+                ("SLACK_BOT_TOKEN", slack_bot_token),
+                ("SLACK_APP_TOKEN", slack_app_token),
+                ("DEEPSEEK_API_KEY", deepseek_api_key),
+            ]
+            if not val
+        ]
+        if missing:
+            sys.exit(
+                f"ERROR: Set WIKI_CHARLESREID1_WORKSPACES (JSON) or provide legacy env vars. "
+                f"Missing: {', '.join(missing)}"
+            )
+        workspaces = [
+            {
+                "name": "default",
+                "slack_bot_token": slack_bot_token,
+                "slack_app_token": slack_app_token,
+                "deepseek_api_key": deepseek_api_key,
+            }
+        ]
+
+    required_keys = {"name", "slack_bot_token", "slack_app_token", "deepseek_api_key"}
+    for i, ws in enumerate(workspaces):
+        missing = required_keys - set(ws.keys())
+        if missing:
+            sys.exit(
+                f"ERROR: Workspace entry {i} is missing keys: {', '.join(sorted(missing))}"
+            )
+
+    return workspaces
+
+
+# ---------------------------------------------------------------------------
+# Build an async Slack app for one workspace
+# ---------------------------------------------------------------------------
+def make_app(ws, mcp_session, all_tools):
+    ws_name = ws["name"]
+    deepseek_api_key = ws["deepseek_api_key"]
+    deepseek_api_url = ws.get("deepseek_api_url", "https://api.deepseek.com/chat/completions")
+    deepseek_model = ws.get("deepseek_model", "deepseek-v4-pro")
+
+    ws_logger = logging.LoggerAdapter(logger, {"workspace": ws_name})
+
+    slack_app = AsyncApp(token=ws["slack_bot_token"])
+
+    @slack_app.event("app_mention")
+    async def handle_mention(event, client, say):
+        channel = event["channel"]
+        message_ts = event["ts"]
+        thread_ts = event.get("thread_ts") or message_ts
+        raw_text = event.get("text", "")
+
+        prompt_text = re.sub(r"<@[A-Z0-9]+>", "", raw_text).strip()
+
+        ws_logger.info("Mention received  channel=%s  ts=%s", channel, message_ts)
+        ws_logger.info("Prompt: %.200r", prompt_text)
+
+        if not prompt_text:
+            ws_logger.info("Empty prompt -- skipping API call")
+            await say(
+                text=(
+                    "You mentioned me but didn't include any prompt text, "
+                    "so I didn't make an API call. "
+                    "Try again with a question or message after the mention."
+                ),
+                thread_ts=thread_ts,
+            )
+            return
+
+        await client.reactions_add(channel=channel, timestamp=message_ts, name="eyes")
+
+        try:
+            ws_logger.info("DeepSeek API call starting  model=%s", deepseek_model)
+            start = time.time()
+
+            reply_text = await chat_with_tools(
+                deepseek_api_url,
+                deepseek_api_key,
+                deepseek_model,
+                prompt_text,
+                ws_logger,
+                mcp_session,
+                all_tools,
+            )
+
+            duration = time.time() - start
+            ws_logger.info(
+                "DeepSeek API call completed  duration=%.2fs  chars=%d",
+                duration,
+                len(reply_text),
+            )
+
+            reply_text = md_to_slack(reply_text)
+
+            if len(reply_text) <= MAX_INLINE_LENGTH:
+                await say(text=reply_text, thread_ts=thread_ts)
+            else:
+                await client.files_upload_v2(
+                    channel=channel,
+                    thread_ts=thread_ts,
+                    content=reply_text,
+                    filename="response.txt",
+                    title="Wiki Bot Response",
+                    initial_comment="The response was too long for an inline message.",
+                )
+
+        except Exception as exc:
+            ws_logger.exception("DeepSeek API call failed")
+            await client.reactions_add(channel=channel, timestamp=message_ts, name="x")
+            await say(text=f"DeepSeek API error: {exc}", thread_ts=thread_ts)
+
+        finally:
+            try:
+                await client.reactions_remove(
+                    channel=channel, timestamp=message_ts, name="eyes"
+                )
+            except Exception:
+                ws_logger.warning("Failed to remove eyes reaction", exc_info=True)
+
+    return slack_app
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+async def main():
+    workspaces = load_workspaces()
+    logger.info("Starting wiki-charlesreid1 bot for %d workspace(s)", len(workspaces))
+
+    mcp_url = os.environ.get("MCP_SERVER_URL", "http://mediawiki-mcp:3000")
+    try:
+        mcp_context, mcp_session, mediawiki_tools = await connect_mcp(mcp_url)
+    except Exception as exc:
+        logger.exception("Failed to connect to MCP server at %s", mcp_url)
+        sys.exit(1)
+
+    all_tools = DEEPSEEK_TOOLS + mediawiki_tools
+    logger.info("Total tools available: %d (built-in) + %d (MediaWiki) = %d",
+                len(DEEPSEEK_TOOLS), len(mediawiki_tools), len(all_tools))
+
+    try:
+        handlers = []
+        for ws in workspaces:
+            slack_app = make_app(ws, mcp_session, all_tools)
+            handler = AsyncSocketModeHandler(slack_app, ws["slack_app_token"])
+            handlers.append(handler.start_async())
+
+        await asyncio.gather(*handlers)
+    finally:
+        await mcp_context.__aexit__(None, None, None)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

wiki-charlesreid1/requirements.txt

@@ -0,0 +1,6 @@
+slack-bolt>=1.28.0
+aiohttp>=3.9.0
+httpx>=0.28.1
+md2mrkdwn>=0.4.3
+duckduckgo-search>=8.0.0
+mcp>=1.0.0