@cursor/july 0.1.7 → 0.1.9

package/docs/example-agents/oncall.md

@@ -0,0 +1,216 @@
+---
+title: "Investigate every alert in its own Slack thread"
+description: "Watch a bot-fed alerts channel, react when the agent locks in, coalesce thread chatter behind a quiet window, and let the agent schedule its own re-checks."
+---
+
+# Investigate every alert in its own Slack thread
+
+This agent is an on-call teammate. Alert feeds post into an alerts channel
+as bots. Each new alert dispatches an investigation session pinned to that
+post's thread: the agent reacts 👀 the moment it locks in, investigates
+immediately, and posts brief findings backed by evidence it observed.
+Replies in the thread reach it only after the thread has been quiet for
+about a minute, and reminder tools let it wake itself later to re-check a
+baseline or confirm an alert cleared.
+
+Use this example when alerts land in Slack and you want one thread-scoped
+investigation per alert, with an agent that paces its own engagement
+instead of answering every message.
+
+[Browse the current alert-investigator source.](../../examples/oncall/)
+
+## Follow an alert
+
+1. An alert feed (Alertmanager, PagerDuty, Datadog) posts a new top-level
+   message in the watched alerts channel.
+2. The channel watch accepts it. `includeBotPosts` lets bot authors
+   through; the agent's own posts always stay dropped.
+3. The handler reacts 👀 on the alert post and sets "Investigating…"
+   typing. The reaction is the lock-in signal: this alert has an owner.
+4. Agentkit creates a session keyed to the alert's thread and dispatches
+   immediately. New alerts get no debounce.
+5. The agent reads the alert, gathers evidence, and posts findings to the
+   thread once it has a hypothesis.
+6. People discuss in the thread. Replies buffer per thread and dispatch as
+   one coalesced follow-up after roughly a minute of quiet.
+7. The agent arms reminders for anything that needs time and posts interim
+   updates when new evidence changes the picture.
+
+Mentions and DMs skip the watch entirely and behave like ordinary chat.
+
+## Map the files
+
+| File | Purpose |
+| --- | --- |
+| [`agent/agent.ts`](../../examples/oncall/agent/agent.ts) | Names the agent and keeps harness workspaces outside any monorepo checkout. |
+| [`agent/instructions.md`](../../examples/oncall/agent/instructions.md) | Engagement rules, the investigation loop, and the message discipline. |
+| [`agent/channels/slack-app.ts`](../../examples/oncall/agent/channels/slack-app.ts) | Dedicated Socket Mode app: watch configuration and handler wiring. |
+| [`agent/lib/alert-watch.ts`](../../examples/oncall/agent/lib/alert-watch.ts) | The engagement policy: lock in on new alerts, coalesce replies. |
+| [`agent/lib/thread-debounce.ts`](../../examples/oncall/agent/lib/thread-debounce.ts) | Per-thread quiet window. |
+| [`agent/lib/alerts.ts`](../../examples/oncall/agent/lib/alerts.ts) | Dispatch classification, prompt building, and thread addressing. |
+| [`agent/lib/slack-api.ts`](../../examples/oncall/agent/lib/slack-api.ts) | Reactions and thread posts on this agent's own token pair. |
+| [`agent/tools/reminders_create.ts`](../../examples/oncall/agent/tools/reminders_create.ts) | Self-scheduled wakes bound to the thread (plus `reminders_list` and `reminders_cancel`). |
+| [`agent/tools/post_thread_update.ts`](../../examples/oncall/agent/tools/post_thread_update.ts) | Interim updates to the thread mid-turn. |
+| [`evals/smoke.eval.ts`](../../examples/oncall/evals/smoke.eval.ts) | Checks identity and the reminder-tool route. |
+
+## Let bot posts through the watch
+
+Channel watching drops bot-authored posts by default so two agents can
+never feed each other. Alert channels invert the assumption: the posts
+worth watching come from bots. `channelPosts.includeBotPosts` opts in per
+channel:
+
+```ts
+engagement: {
+  channelPosts: {
+    allow: ["#alerts"],
+    posts: "all",
+    includeBotPosts: true,
+  },
+},
+```
+
+Loop safety survives the opt-in. The pack matches the watching app's own
+posts by the `bot_id` and bot user id from `auth.test` and drops them, so
+the agent's findings never re-dispatch it. Posts that mention the bot stay
+on the mention path.
+
+`posts: "all"` also delivers thread replies. The handler, not the pack,
+decides their pace.
+
+## Pace the engagement
+
+The example runs two rhythms:
+
+- A new alert dispatches immediately.
+- Thread replies produce one engagement per lull.
+
+The pack's `debounceMs` is per message; it exists to let edits settle. This
+agent needs a per-thread window instead, so the handler owns it
+([`lib/thread-debounce.ts`](../../examples/oncall/agent/lib/thread-debounce.ts)).
+Every reply restarts a 60-second timer keyed by thread. Superseded waiters
+resolve `null` and the handler returns `null` for them. When the thread
+goes quiet, the newest waiter receives the whole batch and dispatches one
+follow-up that lists every message with mentionable attribution.
+
+Two details make the window matter. A follow-up that arrives while a turn
+runs preempts that turn (latest message wins), so engaging per message
+would keep cancelling the investigation. And @mentions bypass the window
+through Slack's mention path, so a person who needs the agent now still
+gets it now.
+
+## Schedule your own re-checks
+
+Investigations rarely finish in one pass. A baseline comparison needs 20
+minutes of data. An alert that cleared may re-fire. The example hands the
+model three tools over `host.reminders`:
+
+- `reminders_create` arms a one-shot (`delay: "20m"`) or recurring
+  (`every: "30m"` with a plain-language stop condition) wake bound to the
+  thread's conversation.
+- `reminders_list` shows the thread's standing watches.
+- `reminders_cancel` disarms one, and refuses ids that belong to another
+  thread's conversation.
+
+When a reminder fires, its prompt returns to the same session as a
+follow-up turn, and the reply lands in the alert thread. The instructions
+keep wake prompts generic (re-read live state instead of replaying stale
+numbers) and wake replies to one line, for example "re-checked p99 on
+api-gateway: 120ms, back at baseline, cancelling the watch."
+
+Keep these tool filenames if you copy the design: the framework's reminder
+fire prompt tells the model to call `reminders_cancel` by name when a stop
+condition is set.
+
+## Alert people mid-investigation
+
+The final reply of each turn posts to the thread on its own.
+`post_thread_update` covers evidence that shouldn't wait for the turn to
+finish: it posts a one-or-two-sentence update through the agent's token,
+with `<@USERID>` mentions for the people who need to act. The instructions
+restrict it to changes in hypothesis, severity, or blast radius. Progress
+narration doesn't qualify.
+
+## Connect the Slack app
+
+Channel watching is Socket Mode only, so this example uses a dedicated
+app:
+
+```bash
+agentkit slack init --dir examples/oncall --name "Oncall" --channel-posts
+agentkit slack doctor --prefix ONCALL
+```
+
+The generated manifest subscribes to `message.channels` and
+`message.groups` and includes `reactions:write` for the lock-in reaction.
+Install the app, export `ONCALL_SLACK_BOT_TOKEN` and
+`ONCALL_SLACK_APP_TOKEN`, and invite the bot to each watched channel.
+
+`ONCALL_ALERTS_CHANNELS` sets the watch list as comma-separated ids or
+`#names`. It defaults to `#alerts`.
+
+Wire observability MCP servers under `agent/mcp-connections/` so evidence
+gathering reaches your logs, metrics, and dashboards. The example ships
+none; without them the agent works from the alert text, its links, and the
+thread.
+
+## Validate and start the server
+
+```bash
+agentkit validate --dir examples/oncall
+agentkit info --dir examples/oncall --json
+agentkit dev examples/oncall
+```
+
+The info output lists four server tools and the watched channel on the
+`slack-app` channel. Missing tokens leave that channel idle without
+stopping the server.
+
+In dev mode, reminder timers don't auto-fire. List and fire them by hand
+through the dev routes described in
+[Schedules and reminders](../reference/schedules.md#dispatch-and-dev-mode).
+
+## Test the policy without Slack
+
+The engagement policy is plain code with unit tests:
+
+```bash
+pnpm exec vitest run examples/oncall
+```
+
+The integration test drives a synthetic Events API delivery through the
+real parse, watch, and dispatch plumbing. It asserts a bot alert
+dispatches pinned to its thread after the lock-in reaction, the agent's
+own posts never loop, and replies coalesce behind the quiet window.
+
+The smoke eval spends a model turn:
+
+```bash
+agentkit eval --dir examples/oncall smoke --json
+```
+
+It checks identity and the reminder-tool route lexically. It doesn't prove
+Slack delivery or reaction behavior; the unit tests cover the dispatch
+side, and a live check needs the dedicated app connected.
+
+## Build an alert investigator
+
+Use this structure when a bot feed should drive thread-scoped work:
+
+1. Watch the feed channel with `includeBotPosts: true` and a narrow
+   allowlist.
+2. Acknowledge on the triggering post before dispatching, so people see
+   ownership without opening the thread.
+3. Dispatch new items immediately; coalesce thread chatter behind a
+   per-thread quiet window.
+4. Give the agent reminder tools for anything that needs time, and make
+   cancel discipline part of the instructions.
+5. Keep every posted message brief and tied to evidence the agent saw.
+
+## Where to go next
+
+- [Slack](../guides/slack.md)
+- [Schedules and reminders](../reference/schedules.md)
+- [Tools](../reference/tools.md)
+- [Playbook router](./benny.md) for the human-post variant of channel
+  watching

package/docs/example-agents/security-reviewer.md

@@ -71,7 +71,7 @@ status from the finding count even when the review posting result says
 | Progress channel | [`agent/channels/asr-progress.ts`](../../examples/security-reviewer/agent/channels/asr-progress.ts) | Serve live reviewer and triage state by `runId`. |
 | Playground renderer | [`agent/playground/tools/run_reviewers.tsx`](../../examples/security-reviewer/agent/playground/tools/run_reviewers.tsx) | Replace the generic tool chip with live module rows. |
 | SDK review pipeline | [`agent/lib/asr/`](../../examples/security-reviewer/agent/lib/asr/), [`review-stages.ts`](../../examples/security-reviewer/agent/lib/review-stages.ts) | Select modules, call model workers, triage, deduplicate, and write artifacts. |
-| Storage | [`agent/storage.ts`](../../examples/security-reviewer/agent/storage.ts) | Persist framework sessions through a custom adapter with lazy restore. |
+| Storage | [`agent/storage.ts`](../../examples/security-reviewer/agent/storage.ts) | Persist framework sessions with `cursorHostedStorage` (lazy restore). |
 | A/B | [`agent/ab.ts`](../../examples/security-reviewer/agent/ab.ts), [`agent/ab.config.ts`](../../examples/security-reviewer/agent/ab.config.ts) | Compare all-severity versus high-only GitHub comments. |
 | Eval | [`evals/`](../../examples/security-reviewer/evals/) | Check stage-tool presence against a pinned sample. |
 
@@ -190,10 +190,10 @@ findings, accounting, and audit events.
 
 ## Separate session storage from review artifacts
 
-`defineStorage` sends agentkit session and event records to a custom durable
-store. Security Reviewer sets `restore: "off"` so startup doesn't load old
-review sessions in bulk. A continuation lookup can still fetch a needed
-session.
+`defineStorage` + `cursorHostedStorage` sends agentkit session and event records
+to Cursor-hosted Bugbot storage through the control-plane proxy. Security
+Reviewer sets `restore: "off"` so startup doesn't load old review sessions in
+bulk. A continuation lookup can still fetch a needed session.
 
 The staged review files are separate from session storage. Session-store
 durability doesn't preserve those files. All stages for one `runId` must see

package/docs/guides/slack.md

@@ -146,6 +146,7 @@ export default slackChannel({
       allow: ["#triage-alerts"], // explicit allowlist; no wildcard exists
       posts: "top-level",       // default: thread replies never dispatch
       debounceMs: 15_000,       // optional: let rapid edits settle
+      includeBotPosts: false,   // default: bot-authored posts never dispatch
     },
   },
   onChannelPost: async (ctx, message) => {
@@ -160,12 +161,20 @@ on the Slack app (Socket Mode only — not available with
 `cursorAccount: true`). Generate manifests with `slack init --channel-posts`,
 or add the events and re-import. The bot must also be a member of each
 watched channel. Posts that mention the bot stay on the `app_mention`
-path, bot-authored posts never dispatch, and deleting a post inside the
-debounce window cancels its dispatch. Watched posts reuse the
+path, bot-authored posts never dispatch by default, and deleting a post
+inside the debounce window cancels its dispatch. Watched posts reuse the
 thread-scoped principal, so a later @mention continues the same session.
 Set `engagement.mentions` or `engagement.directMessages` to `false` to
 turn those surfaces off.
 
+Set `includeBotPosts: true` when the posts worth watching come from bots:
+alert feeds, webhook integrations, or other agents posting notes. The
+watching app's own posts stay dropped either way, matched by the `bot_id`
+and bot user id from `auth.test`, so an agent can never dispatch on its
+own replies. The
+[alert investigator example](../example-agents/oncall.md) watches a
+bot-fed alerts channel this way.
+
 ## Prepare work on the host
 
 Mention and DM handlers may return a prepared `message`,

package/docs/reference/sessions.md

@@ -50,13 +50,22 @@ Task sessions don't accept follow-ups. Trying one returns `409`.
 
 ## What happens when I send a follow-up?
 
-A follow-up to an idle chat session starts another turn. A follow-up to
-a busy session interrupts the current turn, waits for it to settle, and
-then sends the new message.
+A follow-up to an idle chat session starts another turn. Admission when
+the session is already busy depends on the channel:
+
+| Path | Busy-session policy |
+| --- | --- |
+| HTTP playground / `POST /v1/session/:id` / MCP `ask` | **Preempt** (default): interrupt the in-flight turn, wait for it to settle, then run the new message |
+| Slack mentions / DMs / alert-watch | **Coalesce**: leave the active turn running, enqueue the follow-up, and drain queued asks into one follow-up turn when the active turn finishes (no mid-turn tool/hook inject) |
+
+Pass `admission: "coalesce"` on `send()` to opt into the Slack policy from
+other callers. Omit it (or pass `"preempt"`) to keep interrupt semantics.
 
 `POST /v1/session/:id/stop` interrupts a turn without sending a new
 message. Interrupted turns record `turn.failed` with
-`"turn interrupted"`. This means the turn was preempted.
+`"turn interrupted"`. This means the turn was preempted. A whole-message
+Slack `stop` / `@agent stop` does the same for that thread and clears
+pending coalesced nudges.
 
 Session-bound deterministic tool calls share the same execution lock.
 They return `409 session_busy` while a model turn is running.

package/docs/storage.md

@@ -96,3 +96,44 @@ With `get` and `list`, serve can rebuild local state from your store:
 
 A turn in flight at crash time is not replayed. The next follow-up
 resumes from the last flushed state.
+
+## Author KV (`ctx.host.kv`)
+
+Handlers can store their own JSON under the same sink without minting
+framework keys:
+
+```ts
+await ctx.host.kv.put("alert-memory/abc", { updated: "…" });
+const prior = await ctx.host.kv.get("alert-memory/abc");
+```
+
+agentkit prefixes author keys as `agentkit/v1/{agent}/kv/{key}` (same
+bounded encoding as continuation tokens). Writes **await** the sink and
+propagate errors — unlike session mirrors, which are at-most-once.
+
+Without `agent/storage.ts`, `host.kv` falls back to files under
+`--state-root/kv`. That is fine for local dogfood; it does **not**
+survive replacing the host. For Cursor-managed hosting, prefer
+`@cursor/july/storage/cursor-hosted` so sessions and author KV share the
+platform Bugbot tables through a control-plane HTTP proxy (authenticated
+as the deployment pod credential — engines never receive a database URL).
+For self-hosted Postgres you own, use `@cursor/july/storage/postgres-kv`
+and supply `BUGBOTDB_URL` / `AGENT_SERVE_DEPLOYMENT_ID` yourself.
+
+```ts
+// agent/storage.ts — Cursor-managed hosting
+import { defineStorage } from "@cursor/july/storage";
+import { cursorHostedStorage } from "@cursor/july/storage/cursor-hosted";
+
+export default defineStorage({
+  ...cursorHostedStorage(),
+});
+```
+
+Built-in helpers:
+
+| Import | Backend |
+| --- | --- |
+| `@cursor/july/storage/file-kv` | File-per-key under `.agent-serve/kv` |
+| `@cursor/july/storage/cursor-hosted` | Platform Bugbot `agent_serve_*` via control-plane proxy |
+| `@cursor/july/storage/postgres-kv` | Same tables; you supply `BUGBOTDB_URL` / `AGENT_SERVE_DEPLOYMENT_ID` |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cursor/july",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "(early alpha) Filesystem-first framework for defining Cursor agents as markdown and TypeScript and serving them over channels with the Cursor SDK.",
   "license": "SEE LICENSE IN LICENSE.md",
   "repository": {
@@ -124,6 +124,27 @@
       "import": "./dist/storage.js",
       "default": "./dist/storage.js"
     },
+    "./storage/file-kv": {
+      "anysphere-source": "./src/storage-backends/file-kv.ts",
+      "bun": "./src/storage-backends/file-kv.ts",
+      "types": "./dist/storage-backends/file-kv.d.ts",
+      "import": "./dist/storage-backends/file-kv.js",
+      "default": "./dist/storage-backends/file-kv.js"
+    },
+    "./storage/postgres-kv": {
+      "anysphere-source": "./src/storage-backends/postgres-kv.ts",
+      "bun": "./src/storage-backends/postgres-kv.ts",
+      "types": "./dist/storage-backends/postgres-kv.d.ts",
+      "import": "./dist/storage-backends/postgres-kv.js",
+      "default": "./dist/storage-backends/postgres-kv.js"
+    },
+    "./storage/cursor-hosted": {
+      "anysphere-source": "./src/storage-backends/cursor-hosted.ts",
+      "bun": "./src/storage-backends/cursor-hosted.ts",
+      "types": "./dist/storage-backends/cursor-hosted.d.ts",
+      "import": "./dist/storage-backends/cursor-hosted.js",
+      "default": "./dist/storage-backends/cursor-hosted.js"
+    },
     "./package.json": {
       "anysphere-source": "./package.json",
       "bun": "./package.json",

package/skills/framework-map/SKILL.md

@@ -97,10 +97,12 @@ Two handles, two owners:
 - **sessionId** — runtime-owned handle for streaming/inspection
   (`GET /v1/session/:id/stream?startIndex=N`, durable NDJSON replay).
 
-A follow-up to a busy session **interrupts the in-flight turn** and waits
-for it to settle before the new turn sends. `POST /v1/session/:id/stop`
-interrupts without sending. Session-bound deterministic tool calls are
-rejected with `409 session_busy` while a turn runs.
+A follow-up to a busy HTTP/MCP session **interrupts the in-flight turn**
+and waits for it to settle before the new turn sends. Slack uses
+**coalesce** instead (enqueue + boundary drain; see
+`docs/reference/sessions.md`). `POST /v1/session/:id/stop` interrupts
+without sending. Session-bound deterministic tool calls are rejected with
+`409 session_busy` while a turn runs.
 
 Key built-in routes (each agent, under `/<slug>` in multi-agent mode):
 `POST /v1/session`, `POST /v1/session/:id`, `GET /v1/session/:id/stream`,

package/src/bin/agent-serve.ts

@@ -89,6 +89,10 @@ Usage:
   ${CLI} call        <tool> [--input <json>] [--dir <path> | --url <baseUrl> | --prod]
                           [--session <id>] [--slug <slug>] [--team <id>]
   ${CLI} init        [dir] [--json]
+  ${CLI} mcp         --prod [--slug <slug>] [--team <id>] [--dir <path>]
+                          | --url <baseUrl> [--bearer-token <t>]
+  ${CLI} mcp install [--name <serverName>] [--print] [--json]
+                          (same target flags as mcp)
   ${CLI} eval        [--dir <path>] [evalId...] [--list] [--json]
                           [--tag <tag>]... [--verbose] [--timeout-ms <n>]
                           [--no-stream] [--no-wait]
@@ -158,6 +162,15 @@ Commands:
               run login when unsigned, then print next steps. --json is
               machine-readable and never blocks on login. No directory:
               print the setup guide.
+  mcp         Serve this agent's MCP endpoint over stdio for MCP clients
+              that spawn local servers (e.g. Cursor). Proxies
+              newline-delimited JSON-RPC to <target>/v1/mcp. --prod resolves
+              the hosted deployment with the signed-in Cursor account and
+              re-mints short-lived engine credentials as they expire;
+              --url targets a running server. stdout is reserved for the
+              MCP wire. \`mcp install\` writes the matching entry into
+              ~/.cursor/mcp.json (--print to preview; --name to override
+              the server name).
   eval        Run filesystem evals under evals/**/*.eval.ts (streams on a TTY).
               Default: ephemeral local harness against evals on disk. Pass
               --prod to kick off the batch on the team's hosted deployment
@@ -418,8 +431,9 @@ async function main(argv: string[]): Promise<number> {
   const dir = values.dir ?? ".";
 
   // Best-effort, cached, and silent on failure. `update` does its own fresh
-  // lookup, and --json runs stay quiet for machine consumers.
-  if (command !== "update" && values.json !== true) {
+  // lookup, --json runs stay quiet for machine consumers, and `mcp` skips it
+  // so MCP client spawns stay fast (stdout there is the protocol wire).
+  if (command !== "update" && command !== "mcp" && values.json !== true) {
     await warnIfOutdated();
   }
 
@@ -486,6 +500,22 @@ async function main(argv: string[]): Promise<number> {
       });
     }
 
+    case "mcp": {
+      const { cmdMcp } = await import("../internal/cli-mcp.js");
+      return cmdMcp(positionals[0], {
+        dir,
+        slug: values.slug,
+        team: values.team,
+        apiKey: values["api-key"],
+        url: values.url,
+        prod: values.prod,
+        bearerToken: values["bearer-token"],
+        name: values.name,
+        print: values.print,
+        json: values.json,
+      });
+    }
+
     case "login": {
       const { cmdLogin } = await import("../internal/cli-cursor.js");
       return cmdLogin({

package/src/channels/slack/channel-watch.ts

@@ -6,7 +6,10 @@
  * - Top-level posts only by default; thread replies never dispatch unless
  *   `posts: "all"` is configured.
  * - Posts that @mention the bot are skipped here (the `app_mention` path
- *   owns them), and bot-authored posts are dropped upstream in parsing.
+ *   owns them).
+ * - Bot-authored posts are dropped unless `includeBotPosts` is configured
+ *   (alert feeds / webhook integrations); the watching bot's own posts are
+ *   always dropped either way (loop safety).
  * - An optional debounce window lets rapid edits settle: edits update the
  *   pending text, deleting the post cancels the dispatch.
  */
@@ -114,11 +117,14 @@ export function createChannelPostWatcher(args: {
   allowlist: SlackChannelAllowlist;
   /** Bot user id (from `auth.test`) so bot mentions route via app_mention. */
   getBotUserId: () => string | undefined;
+  /** This app's own `bot_id` (from `auth.test`) for self-post loop safety. */
+  getBotId?: () => string | undefined;
   dispatch: (message: SlackMessage, eventId?: string) => void;
   log?: SlackLog;
 }): ChannelPostWatcher {
   const log = args.log ?? defaultSlackLog;
   const includeReplies = args.options.posts === "all";
+  const includeBotPosts = args.options.includeBotPosts === true;
   const debounceMs = args.options.debounceMs ?? 0;
   const pending = new Map<
     string,
@@ -185,6 +191,27 @@ export function createChannelPostWatcher(args: {
         return skip("thread reply (posts: top-level)", message);
       }
       const botUserId = args.getBotUserId();
+      const author = message.author;
+      if (author?.isBot === true) {
+        if (!includeBotPosts) {
+          return skip("bot-authored post (includeBotPosts off)", message);
+        }
+        const selfBotId = args.getBotId?.();
+        if (selfBotId === undefined && botUserId === undefined) {
+          return skip(
+            "bot-authored post (bot identity unknown; loop safety)",
+            message
+          );
+        }
+        if (
+          (selfBotId !== undefined && author.botId === selfBotId) ||
+          (botUserId !== undefined &&
+            author.userId !== "" &&
+            author.userId === botUserId)
+        ) {
+          return skip("own post (loop safety)", message);
+        }
+      }
       if (botUserId !== undefined && message.text.includes(`<@${botUserId}>`)) {
         return skip("bot mention (app_mention path owns it)", message);
       }

package/src/channels/slack/cursor-account.ts

@@ -114,6 +114,12 @@ export async function dispatchCursorSlackEnvelope(args: {
   envelope: CursorSlackEnvelope;
   send: SendMessageFn;
   host: HostContext;
+  hasContinuationSession?: (continuationToken: string) => Promise<boolean>;
+  isContinuationBusy?: (continuationToken: string) => Promise<boolean>;
+  getContinuationLastBotMessageTs?: (
+    continuationToken: string
+  ) => Promise<string | undefined>;
+  interruptContinuation?: (continuationToken: string) => Promise<boolean>;
 }): Promise<void> {
   const { runtime, envelope } = args;
   const log = runtime.getLog();
@@ -161,6 +167,20 @@ export async function dispatchCursorSlackEnvelope(args: {
     credentials: runtime.credentials,
     host: args.host,
     log,
+    ...(args.hasContinuationSession === undefined
+      ? {}
+      : { hasContinuationSession: args.hasContinuationSession }),
+    ...(args.isContinuationBusy === undefined
+      ? {}
+      : { isContinuationBusy: args.isContinuationBusy }),
+    ...(args.getContinuationLastBotMessageTs === undefined
+      ? {}
+      : {
+          getContinuationLastBotMessageTs: args.getContinuationLastBotMessageTs,
+        }),
+    ...(args.interruptContinuation === undefined
+      ? {}
+      : { interruptContinuation: args.interruptContinuation }),
     ...(envelope.eventId === undefined ? {} : { eventId: envelope.eventId }),
   });
 }