@openhands/extensions 0.1.0 → 0.2.0

package/skills/slack-channel-monitor/SKILL.md

@@ -0,0 +1,276 @@
+---
+name: slack-channel-monitor
+description: >
+  This skill should be used when the user asks to "monitor a Slack channel",
+  "watch Slack for messages", "create a Slack bot that responds to mentions",
+  "set up an OpenHands Slack integration", "trigger OpenHands from Slack",
+  "respond to @openhands in Slack", or "poll Slack channels for a trigger
+  phrase". Guides the user through creating a cron automation that watches up
+  to 10 Slack channels and starts an OpenHands conversation whenever a
+  configurable trigger phrase is detected.
+triggers:
+  - /slack-monitor:poll
+---
+
+# Slack Channel Monitor
+
+Create a cron automation that polls up to 10 Slack channels every minute.
+When a message containing the **trigger phrase** (default: `@openhands`) is
+detected it:
+
+1. Adds a 👀 reaction to the triggering message.
+2. Opens an OpenHands conversation with the message and recent channel context.
+3. Posts a reply in the Slack thread with a link to the conversation.
+
+On every subsequent run:
+- Replies in the thread are forwarded to the running conversation.
+- When the conversation finishes (or errors), the agent's final response is
+  posted back to the Slack thread.
+
+> **Local mode only.** This automation targets the local OpenHands setup
+> (`dev:automation` stack). A cloud/webhook-based variant is out of scope here.
+
+---
+
+## Prerequisites
+
+### Required secrets
+
+Verify that at least one of the following secrets is set in
+**OpenHands Settings → Secrets** before proceeding:
+
+| Secret name | Token type | Minimum scopes |
+|---|---|---|
+| `SLACK_BOT_TOKEN` | Bot (`xoxb-…`) | `channels:history`, `channels:read`, `reactions:write`, `chat:write` |
+| `SLACK_USER_TOKEN` | User (`xoxp-…`) | Same as bot, plus `search:read` for multi-channel efficiency |
+
+Check with:
+```bash
+# For bot token:
+curl -s https://slack.com/api/auth.test -H "Authorization: Bearer $SLACK_BOT_TOKEN" \
+  | python3 -c "import json,sys; d=json.load(sys.stdin); print('ok' if d.get('ok') else d.get('error'))"
+
+# For user token:
+curl -s https://slack.com/api/auth.test -H "Authorization: Bearer $SLACK_USER_TOKEN" \
+  | python3 -c "import json,sys; d=json.load(sys.stdin); print('ok' if d.get('ok') else d.get('error'))"
+```
+
+If neither token is present, inform the user and stop  -  the automation cannot
+function without Slack credentials.
+
+### Optional secret
+
+| Secret name | Default | Purpose |
+|---|---|---|
+| `OPENHANDS_URL` | `http://localhost:8000` | Base URL used to build conversation links posted in Slack |
+
+---
+
+## Setup Workflow
+
+Follow these steps in order.
+
+### Step 1  -  Collect channels
+
+Ask the user: *"Which Slack channels should be monitored? You can provide
+channel names (e.g. `#general`) or IDs (e.g. `C0123456789`)."*
+
+**If the user provides channel names**, resolve them to IDs:
+
+```bash
+SLACK_TOKEN="${SLACK_BOT_TOKEN:-$SLACK_USER_TOKEN}"
+curl -s "https://slack.com/api/conversations.list?types=public_channel,private_channel&limit=200&exclude_archived=true" \
+  -H "Authorization: Bearer $SLACK_TOKEN" \
+  | python3 -c "
+import json, sys
+data = json.load(sys.stdin)
+if not data.get('ok'):
+    print('ERROR:', data.get('error'))
+    exit(1)
+names = set(n.lstrip('#') for n in ['CHANNEL_NAMES_HERE'.split(',')])
+for ch in data.get('channels', []):
+    if ch['name'] in names:
+        print(f\"{ch['name']} → {ch['id']}\")
+"
+```
+
+Replace `CHANNEL_NAMES_HERE` with the comma-separated names the user provided.
+
+**If `conversations.list` returns `missing_scope` or `not_authed`:**
+Inform the user: *"The token doesn't have permission to list channels. Please
+provide the channel IDs directly (right-click a channel in Slack → Copy link  - 
+the last path segment starting with `C` is the ID)."*
+
+**If the bot token lacks `channels:read`** for private channels, the user can
+either invite the bot first (`/invite @botname`) or switch to a user token.
+
+Collect up to 10 channel IDs. Record them as a Python list literal, e.g.:
+```python
+["C0123456789", "C9876543210"]
+```
+
+### Step 2  -  Collect trigger phrase
+
+Ask the user: *"What trigger phrase should OpenHands respond to?
+(Press Enter to use the default: `@openhands`)"*
+
+Accepted values: any non-empty string unlikely to appear accidentally, e.g.
+`@openhands`, `jazz hands`, `take-me-to-funky-town`.
+
+### Step 3  -  Generate the automation script
+
+Read `scripts/main.py` from this skill's directory. Apply exactly three
+constant substitutions near the top of the file:
+
+| Placeholder | Replace with |
+|---|---|
+| `TRIGGER_PHRASE = "@openhands"` | `TRIGGER_PHRASE = "{user_phrase}"` |
+| `CHANNEL_IDS: list[str] = []` | `CHANNEL_IDS: list[str] = {channel_id_list}` |
+| `DEFAULT_OPENHANDS_URL = "http://localhost:8000"` | `DEFAULT_OPENHANDS_URL = "{url}"` (keep default if user has no preference) |
+
+Write the customised script to a temporary directory:
+```bash
+mkdir -p /tmp/slack-monitor-build
+# (write the customised main.py to /tmp/slack-monitor-build/main.py)
+```
+
+Validate syntax before packaging:
+```bash
+python3 -m py_compile /tmp/slack-monitor-build/main.py && echo "Syntax OK"
+```
+
+Fix any syntax errors before proceeding.
+
+### Step 4  -  Package and upload
+
+Determine the Automation backend URL and auth from the `<RUNTIME_SERVICES>`
+block in your system context:
+- Use the **Automation backend** `url_from_agent` as `OPENHANDS_HOST`
+- Auth: `X-Session-API-Key: $OPENHANDS_AUTOMATION_API_KEY`
+
+If no Automation backend is listed in `<RUNTIME_SERVICES>`, stop and tell
+the user to start the full automation stack.
+
+```bash
+tar -czf /tmp/slack-monitor.tar.gz -C /tmp/slack-monitor-build .
+
+# OPENHANDS_HOST: read from <RUNTIME_SERVICES> Automation backend url_from_agent
+OPENHANDS_HOST="<automation-url-from-runtime-services>"
+
+TARBALL_PATH=$(curl -s -X POST \
+  "${OPENHANDS_HOST}/api/automation/v1/uploads?name=slack-channel-monitor" \
+  -H "X-Session-API-Key: $OPENHANDS_AUTOMATION_API_KEY" \
+  -H "Content-Type: application/gzip" \
+  --data-binary @/tmp/slack-monitor.tar.gz \
+  | python3 -c "import json,sys; print(json.load(sys.stdin)['tarball_path'])")
+
+echo "Uploaded: $TARBALL_PATH"
+```
+
+If the upload fails with a size error, the tarball must be under 1 MB.
+`main.py` is under 15 KB so this should never trigger.
+
+### Step 5  -  Create the automation
+
+```bash
+curl -s -X POST "${OPENHANDS_HOST}/api/automation/v1" \
+  -H "X-Session-API-Key: $OPENHANDS_AUTOMATION_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d "{
+    \"name\": \"Slack Channel Monitor\",
+    \"trigger\": {\"type\": \"cron\", \"schedule\": \"* * * * *\"},
+    \"tarball_path\": \"$TARBALL_PATH\",
+    \"entrypoint\": \"python3 main.py\",
+    \"timeout\": 55
+  }" | python3 -m json.tool
+```
+
+A 55-second timeout keeps runs well within the 60-second cron window.
+
+Record the returned `id`  -  share it with the user as confirmation.
+
+### Step 6  -  Confirm
+
+Tell the user:
+
+> ✅ **Slack Channel Monitor** is running!
+>
+> - Automation ID: `{id}`
+> - Channels: `{channel list}`
+> - Trigger phrase: `{phrase}`
+> - Polling every minute via cron `* * * * *`
+> - State file: `~/.openhands/workspaces/automation-state/slack_poller_{id}.json`
+>
+> Send a message containing `{phrase}` in any monitored channel to test it.
+> The bot will react with 👀 and reply with a link to the new conversation.
+
+---
+
+## Runtime Behaviour (per poll)
+
+Each cron run executes `main.py`, which runs **10 polling iterations** (every
+5 seconds) within the 55-second timeout window. Each iteration:
+
+1. **Loads state** from the JSON file (see `references/state-schema.md`).
+2. **Resolves the Slack token**  -  checks `SLACK_USER_TOKEN` then `SLACK_BOT_TOKEN`.
+3. **Fetches new messages:**
+   - User token + `search:read` + > 1 channel → single `search.messages` call
+     (searches for the trigger phrase across all channels).
+   - Otherwise → one `conversations.history` call per channel.
+4. **Fetches thread replies**  -  one `conversations.replies` call per tracked thread.
+5. **Processes messages** in chronological order:
+   - Skips messages already in `processed_ts` (dedup across the overlap window).
+   - Skips bot messages and any `ts` in `bot_message_ts`.
+   - Reply in a tracked thread (active **or** closed) → forwards to the existing
+     conversation; re-opens closed conversations automatically.
+   - Contains trigger phrase → 👀 reaction, create conversation, post link.
+     - Thread replies: agent receives full thread history for context.
+     - Root messages: agent receives the trigger text only.
+6. **Checks conversation statuses**  -  for each active conversation where
+   `time.time() - last_activity > 15 s`:
+   - If status is `idle`, `finished`, `error`, or `stuck` → fetch the agent's
+     final response via `/api/conversations/{id}/agent_final_response` and post
+     it to the Slack thread. Mark conversation `closed`.
+7. **Advances `last_poll`** to `now - 10 s` (overlap window prevents boundary
+   races). If a conversation creation failed, pins `last_poll` further back to
+   retry on the next iteration.
+8. **Saves state** (including `processed_ts`) and continues to the next iteration.
+9. After all iterations, fires the completion callback.
+
+Debug output is written to both stdout and a persistent log at:
+```
+{WORKSPACE_BASE_ROOT}/automation-state/slack_poller_debug.log
+```
+
+---
+
+## Additional Resources
+
+### Reference Files
+
+- **`references/slack-api.md`**  -  Slack token types, required scopes, API
+  endpoint reference, rate limits, and common error codes.
+- **`references/state-schema.md`**  -  State JSON schema, field definitions,
+  example file, and conversation lifecycle diagram.
+
+### Script Template
+
+- **`scripts/main.py`**  -  The complete automation script. Customise the three
+  constants at the top (`TRIGGER_PHRASE`, `CHANNEL_IDS`, `DEFAULT_OPENHANDS_URL`)
+  before packaging.
+
+---
+
+## Troubleshooting
+
+| Symptom | Likely cause | Fix |
+|---|---|---|
+| Bot doesn't react to messages | Token missing or bot not in channel | Verify token with `auth.test`; `/invite @botname` |
+| `not_in_channel` error in run logs | Bot token used but bot not a member | Invite bot or switch to user token |
+| `missing_scope` error | Token lacks required scopes | Re-install Slack app with correct scopes (see `references/slack-api.md`) |
+| No messages detected | `last_poll` timestamp is in the future | Delete the state file to reset; it will be recreated on next run |
+| Conversation link 404 | `OPENHANDS_URL` points to wrong host | Set the `OPENHANDS_URL` secret to the correct base URL |
+| Summary never posted | Conversation stuck in `running` state | Check conversation in the OpenHands UI; the agent may need intervention |
+| Duplicate conversations created | `processed_ts` state missing or corrupted | Delete the state file to reset; dedup will rebuild on next run |
+| Trigger message processed on each cron run | State file deleted between runs | Ensure `automation-state/` directory is persistent across runs |
+| Debug info needed | Need detailed per-message trace | Check `{WORKSPACE_BASE_ROOT}/automation-state/slack_poller_debug.log` |

package/skills/slack-channel-monitor/commands/slack-monitor:poll.md

@@ -0,0 +1,8 @@
+---
+# auto-generated by sync_extensions.py
+description: This skill should be used when the user asks to "monitor a Slack channel", "watch Slack for messages", "create a Slack bot that responds to mentions", "set up an OpenHands Slack integration", "trigger OpenHands from Slack", "respond to @openhands in Slack", or "poll Slack channels for a trigger phrase". Guides the user through creating a cron automation that watches up to 10 Slack channels and starts an OpenHands conversation whenever a configurable trigger phrase is detected.
+---
+
+Read and follow the complete instructions in the SKILL.md file located in this skill's directory.
+
+$ARGUMENTS

package/skills/slack-channel-monitor/references/slack-api.md

@@ -0,0 +1,207 @@
+# Slack API Reference
+
+Reference material for the `slack-channel-monitor` skill. Consult this file
+when resolving token issues, diagnosing permission errors, or adjusting the
+polling strategy.
+
+---
+
+## Token Types
+
+| Type | Prefix | Typical source | Relevant scopes |
+|------|--------|---------------|-----------------|
+| **Bot token** | `xoxb-` | OAuth install / Slack App → Install App | `channels:history`, `channels:read`, `reactions:write`, `chat:write` |
+| **User token** | `xoxp-` | OAuth flow on behalf of a workspace member | Same as bot + `search:read` for multi-channel search |
+
+### Choosing a token
+
+- **Prefer a bot token** for single-channel monitoring or when `search:read` is
+  unavailable. One `conversations.history` call per channel per minute is fine
+  for < 10 channels.
+- **Use a user token** with `search:read` when monitoring multiple channels, to
+  reduce API calls by querying all channels in a single `search.messages` request.
+
+### Checking token type at runtime
+
+The script detects token type by checking which secret name is set:
+
+1. `SLACK_USER_TOKEN` (checked first  -  user token preferred for multi-channel)
+2. `SLACK_BOT_TOKEN`
+
+Set the appropriate secret in **OpenHands Settings → Secrets**.
+
+---
+
+## Required Scopes
+
+### Bot token (`xoxb-`)
+
+| Scope | Used for |
+|-------|----------|
+| `channels:history` | Read messages from public channels |
+| `groups:history` | Read messages from private channels (if monitoring any) |
+| `channels:read` | Resolve channel names → IDs |
+| `reactions:write` | Add 👀 reaction to trigger messages |
+| `chat:write` | Post conversation links and summaries back to Slack |
+
+### User token (`xoxp-`)  -  additional scope
+
+| Scope | Used for |
+|-------|----------|
+| `search:read` | `search.messages` across multiple channels in one request |
+
+---
+
+## Relevant API Endpoints
+
+### `conversations.history`
+Fetch messages from a single channel newer than a timestamp.
+
+```
+GET https://slack.com/api/conversations.history
+  ?channel=CHANNEL_ID
+  &oldest=UNIX_TIMESTAMP        (exclusive  -  messages strictly after this)
+  &limit=100
+  &inclusive=false
+```
+
+Returns a `messages` array. Each message has `ts`, `user`, `text`, `thread_ts`
+(present if the message is in a thread or is a threaded reply).
+
+**Bot must be invited to the channel** (or the token must have `channels:history`
+for public channels without joining).
+
+---
+
+### `conversations.replies`
+Fetch replies inside a specific thread newer than a timestamp.
+
+```
+GET https://slack.com/api/conversations.replies
+  ?channel=CHANNEL_ID
+  &ts=THREAD_ROOT_TS
+  &oldest=UNIX_TIMESTAMP
+  &limit=100
+  &inclusive=false
+```
+
+The first item in `messages` is always the parent message  -  the script drops it
+when comparing `ts == thread_root_ts`.
+
+---
+
+### `search.messages`
+Search for messages matching a query across channels (user token only).
+
+```
+GET https://slack.com/api/search.messages
+  ?query=QUERY_STRING
+  &count=100
+  &sort=timestamp
+  &sort_dir=asc
+```
+
+**Query syntax used by this skill:**
+
+```
+"@openhands" in:<#C0123456> in:<#C9876543> after:2026-01-01
+```
+
+- `in:<#CHANNEL_ID>`  -  restrict to a channel (channel ID or name both work)
+- `after:YYYY-MM-DD`  -  date-level precision only (the script post-filters by
+  precise Unix timestamp)
+- Phrase in quotes  -  exact match
+
+**Limitations:**
+- Date-only precision for `after:`  -  cannot filter to the minute
+- Results sorted by relevance by default; use `sort=timestamp` to get chronological order
+- `count` max is 100 per page (pagination supported via `page` parameter)
+- Requires `search:read` scope  -  not available to bot tokens
+
+---
+
+### `reactions.add`
+Add an emoji reaction to a message.
+
+```
+POST https://slack.com/api/reactions.add
+{
+  "channel": "CHANNEL_ID",
+  "name":    "eyes",
+  "timestamp": "MESSAGE_TS"
+}
+```
+
+Error `already_reacted` is safe to ignore.
+
+---
+
+### `chat.postMessage`
+Post a message to a channel, optionally within a thread.
+
+```
+POST https://slack.com/api/chat.postMessage
+{
+  "channel":   "CHANNEL_ID",
+  "text":      "Message text",
+  "thread_ts": "THREAD_ROOT_TS"   // omit for top-level messages
+}
+```
+
+Returns `ts` of the posted message  -  **store this in `bot_message_ts`** in the
+state file to prevent the bot from processing its own messages.
+
+---
+
+### `conversations.list`
+List channels visible to the token (used to resolve names → IDs during setup).
+
+```
+GET https://slack.com/api/conversations.list
+  ?types=public_channel,private_channel
+  &limit=200
+  &exclude_archived=true
+```
+
+Supports cursor-based pagination via the `response_metadata.next_cursor` field.
+
+---
+
+### `auth.test`
+Verify a token and retrieve the associated user/bot ID.
+
+```
+GET https://slack.com/api/auth.test
+```
+
+Returns `user_id` (used by the script to detect and skip its own messages).
+
+---
+
+## Common Errors
+
+| Error | Cause | Fix |
+|-------|-------|-----|
+| `not_in_channel` | Bot hasn't been invited | `/invite @botname` in the channel |
+| `missing_scope` | Token lacks a required scope | Re-install the Slack app with the correct scopes |
+| `channel_not_found` | Channel ID is wrong | Use `conversations.list` to verify the ID |
+| `ratelimited` | Too many API calls | Slack allows ~50 requests/min per token; < 10 channels is well within limits |
+| `invalid_auth` | Token expired or revoked | Regenerate the token and update the secret |
+
+---
+
+## Rate Limits
+
+Slack applies per-method rate limits (Tier 2 = ~20 req/min, Tier 3 = ~50 req/min).
+With < 10 channels polled every minute:
+
+| Method | Tier | Calls/min | Headroom |
+|--------|------|-----------|---------|
+| `conversations.history` | Tier 3 | ≤ 10 | Comfortable |
+| `conversations.replies` | Tier 3 | ≤ active threads | Fine unless hundreds of threads |
+| `search.messages` | Tier 2 | 1 | Fine |
+| `reactions.add` | Tier 2 | ≤ triggers/min | Fine |
+| `chat.postMessage` | Tier 3 | ≤ triggers + summaries | Fine |
+
+No rate-limit handling is implemented in the script. If you hit limits the
+run will fail and retry on the next cron tick.

package/skills/slack-channel-monitor/references/state-schema.md

@@ -0,0 +1,180 @@
+# State File Schema
+
+The automation maintains a JSON state file that persists across polling runs.
+This file is the source of truth for which conversations are active, which
+timestamps have been processed, and which messages were posted by the bot.
+
+---
+
+## File Location
+
+```
+{WORKSPACE_BASE_ROOT}/automation-state/slack_poller_{automation_id}.json
+```
+
+Where `WORKSPACE_BASE_ROOT` is derived by going two levels up from the
+`WORKSPACE_BASE` environment variable (stripping `automation-runs/{run_id}`).
+
+Example on a local install:
+
+```
+~/.openhands/workspaces/automation-state/slack_poller_abc12345-….json
+```
+
+The `automation_id` is read from the `AUTOMATION_EVENT_PAYLOAD` environment
+variable (field `automation_id`).
+
+---
+
+## Top-Level Schema
+
+```jsonc
+{
+  "version": 1,                        // schema version (integer)
+  "bot_user_id": "UBOTID123",          // Slack user_id of the bot/token owner
+                                       // cached from auth.test; null until first run
+  "last_poll": {
+    "C0123456789": "1716576000.123456" // channel_id → float Unix timestamp (string)
+                                       // set to (now - POLL_OVERLAP_SECONDS) at the
+                                       // END of each run; pinned back if triggers fail
+  },
+  "conversations": { ... },            // see ConversationRecord below
+  "bot_message_ts": [                  // rolling list of Slack 'ts' values for
+    "1716576100.000200"                // messages THIS bot posted; used to skip
+  ],                                   // self-messages during processing
+  "processed_ts": [                    // rolling list of message ts values that have
+    "1716576050.000100"                // already been fully handled (dedup across the
+  ]                                    // overlap window between iterations)
+}
+```
+
+---
+
+## `conversations` Map
+
+Key: `"{channel_id}:{thread_root_ts}"`  -  uniquely identifies a Slack thread.
+
+Value: **ConversationRecord**
+
+```jsonc
+{
+  // Required fields
+  "conversation_id": "550e8400-e29b-41d4-a716-446655440000",
+                                      // OpenHands conversation UUID
+  "channel_id":      "C0123456789",  // Slack channel ID
+  "thread_ts":       "1716576000.000100",
+                                      // Slack thread root timestamp
+                                      // (= msg_ts for top-level trigger messages)
+  "status":          "active",        // "active" | "closed"
+  "last_activity":   1716576060.0,    // float Unix timestamp of the last time the
+                                      // script sent a message to this conversation
+                                      // (creation time, or time a reply was forwarded)
+}
+```
+
+### `status` values
+
+| Value | Meaning |
+|-------|---------|
+| `active` | Conversation is running or awaiting more input; replies will be forwarded |
+| `closed` | Summary has been posted to Slack; no further processing |
+
+Closed conversations are retained in the map indefinitely (the map stays small
+since there are < 10 channels and the trigger rate is typically low). If the
+map grows unexpectedly, closed entries older than a configurable TTL can be
+pruned.
+
+---
+
+## `bot_message_ts` List
+
+A rolling list (max `MAX_BOT_TS = 2000` entries) of Slack `ts` values for
+messages posted BY the bot. This prevents the script from treating its own
+replies as user messages.
+
+Entries are added when:
+- The bot posts a conversation link (on trigger detection)
+- The bot posts a summary (on conversation completion)
+
+---
+
+## `processed_ts` List
+
+A rolling list (max `MAX_PROCESSED_TS = 2000` entries) of Slack `ts` values
+for messages that have already been fully handled by this script.
+
+Because `last_poll` is set to `(now - POLL_OVERLAP_SECONDS)` rather than
+exactly `now`, messages near the boundary are re-fetched on the next iteration.
+`processed_ts` provides a second deduplication layer that prevents these
+re-fetched messages from being processed twice (e.g., triggering a duplicate
+conversation or forwarding the same reply multiple times).
+
+Entries are added when a message is either skipped (not human, already handled)
+or successfully processed (trigger detected and conversation created, or reply
+forwarded).
+
+---
+
+## Transition Diagram
+
+```
+[trigger detected]
+        │
+        ▼
+  status = "active"
+  last_activity = now
+        │
+  (next run or later runs)
+        │
+  ┌─────┴──────────────────────────────────────────┐
+  │  User sends a reply in the thread               │
+  │  → send_to_conversation() called               │
+  │  → last_activity = now                         │
+  └─────────────────────────────────────────────────┘
+        │
+  (when time.time() - last_activity > DONE_DEBOUNCE
+   AND conversation_status ∈ {idle, finished, error, stuck})
+        │
+        ▼
+  Post summary to Slack thread
+  status = "closed"
+```
+
+---
+
+## Example State File
+
+```json
+{
+  "version": 1,
+  "bot_user_id": "U04AB1CDEF",
+  "last_poll": {
+    "C0123456789": "1716576060.000000",
+    "C9876543210": "1716576060.000000"
+  },
+  "conversations": {
+    "C0123456789:1716575900.000100": {
+      "conversation_id": "550e8400-e29b-41d4-a716-446655440000",
+      "channel_id": "C0123456789",
+      "thread_ts": "1716575900.000100",
+      "status": "active",
+      "last_activity": 1716575902.3
+    },
+    "C9876543210:1716570000.000500": {
+      "conversation_id": "7c9e6679-7425-40de-944b-e07fc1f90ae7",
+      "channel_id": "C9876543210",
+      "thread_ts": "1716570000.000500",
+      "status": "closed",
+      "last_activity": 1716572100.0
+    }
+  },
+  "bot_message_ts": [
+    "1716575903.000200",
+    "1716572105.000100"
+  ],
+  "processed_ts": [
+    "1716575900.000100",
+    "1716572000.000500"
+  ]
+}
+```