openbot 0.5.8 → 0.5.10

package/dist/harness/index.js

@@ -7,8 +7,9 @@ import { abortRegistry, abortKey } from '../services/abort.js';
 import { loadConfig } from '../app/config.js';
 import { getPublicBaseUrl } from '../plugins/storage/files.js';
 import { createPluginHost } from '../services/plugins/host.js';
+import { getInvokeConfigOverrides, mergePluginConfig } from './merge-plugin-config.js';
 export { STATE_AGENT_ID, ORCHESTRATOR_AGENT_ID };
-async function emitEvent(chunk, state, { persistEvents, channelId, threadId, onEvent, parentAgentId, parentToolCallId, }) {
+async function emitEvent(chunk, state, { persistEvents, onEvent, parentAgentId, parentToolCallId, }) {
     ensureEventId(chunk);
     // Enrich event with parent metadata if not already present
     if (parentAgentId || parentToolCallId) {
@@ -18,10 +19,11 @@ async function emitEvent(chunk, state, { persistEvents, channelId, threadId, onE
             parentToolCallId: chunk.meta?.parentToolCallId || parentToolCallId,
         };
     }
-    if (persistEvents) {
+    const channelId = state?.channelId;
+    if (persistEvents && channelId) {
         await storageService.storeEvent({
-            channelId: state?.channelId || channelId,
-            threadId: state?.threadId || threadId,
+            channelId,
+            threadId: state?.threadId,
             event: chunk,
         });
     }
@@ -32,7 +34,7 @@ async function emitEvent(chunk, state, { persistEvents, channelId, threadId, onE
  * Fire and forget.
  */
 export async function runAgent(options) {
-    const { runId, agentId, event, channelId, threadId, onEvent } = options;
+    const { runId, agentId, event, onEvent } = options;
     const persistEvents = options.persistEvents !== false;
     let publicBaseUrl = options.publicBaseUrl;
     if (!publicBaseUrl) {
@@ -46,18 +48,16 @@ export async function runAgent(options) {
     const state = await storageService.getOpenBotState({
         runId,
         agentId,
-        channelId,
-        threadId,
         event,
     });
     // Shared per-thread abort signal so a stop request cancels this run and any
     // delegated sub-agent runs (which execute in the same channel/thread).
-    const runKey = abortKey(channelId, threadId);
+    const runKey = state.channelId ? abortKey(state.channelId, state.threadId) : runId;
     const abortSignal = abortRegistry.acquire(runKey);
     await emitEvent({
         type: 'agent:run:start',
-        data: { runId, agentId, channelId, threadId },
-    }, state, { persistEvents, channelId, threadId, onEvent, parentAgentId, parentToolCallId });
+        data: { runId, agentId, channelId: state.channelId, threadId: state.threadId },
+    }, state, { persistEvents, onEvent, parentAgentId, parentToolCallId });
     try {
         const pluginRefs = agentDetails.pluginRefs ?? [];
         const tools = {};
@@ -69,6 +69,11 @@ export async function runAgent(options) {
         }
         const builder = melony().initialState(state);
         const pluginHost = createPluginHost(runAgent);
+        const invokeConfigOverrides = getInvokeConfigOverrides(event);
+        const pluginConfigs = Object.fromEntries(pluginRefs.map((ref) => [
+            ref.id,
+            mergePluginConfig(ref.config, invokeConfigOverrides, ref.id),
+        ]));
         for (const ref of pluginRefs) {
             const plugin = await resolvePlugin(ref.id);
             if (!plugin)
@@ -76,7 +81,7 @@ export async function runAgent(options) {
             builder.use(plugin.factory({
                 agentId,
                 agentDetails,
-                config: ref.config ?? {},
+                config: pluginConfigs[ref.id],
                 storage: storageService,
                 tools,
                 publicBaseUrl,
@@ -91,8 +96,6 @@ export async function runAgent(options) {
                 break;
             await emitEvent(outputEvent, state, {
                 persistEvents,
-                channelId,
-                threadId,
                 onEvent,
                 parentAgentId,
                 parentToolCallId,
@@ -106,7 +109,7 @@ export async function runAgent(options) {
         abortRegistry.release(runKey);
         await emitEvent({
             type: 'agent:run:end',
-            data: { runId, agentId, channelId, threadId },
-        }, state, { persistEvents, channelId, threadId, onEvent, parentAgentId, parentToolCallId });
+            data: { runId, agentId, channelId: state.channelId, threadId: state.threadId },
+        }, state, { persistEvents, onEvent, parentAgentId, parentToolCallId });
     }
 }

package/dist/harness/merge-plugin-config.js

@@ -0,0 +1,26 @@
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isPluginKeyedConfig(config) {
+    return Object.values(config).every(isPlainObject);
+}
+export function getInvokeConfigOverrides(event) {
+    if (event.type !== 'agent:invoke')
+        return undefined;
+    const config = event.data?.config;
+    if (!isPlainObject(config) || Object.keys(config).length === 0)
+        return undefined;
+    return config;
+}
+export function mergePluginConfig(base, overrides, pluginId) {
+    const baseConfig = base ?? {};
+    if (!overrides)
+        return baseConfig;
+    if (isPluginKeyedConfig(overrides)) {
+        const pluginOverride = overrides[pluginId];
+        if (!isPlainObject(pluginOverride))
+            return baseConfig;
+        return { ...baseConfig, ...pluginOverride };
+    }
+    return { ...baseConfig, ...overrides };
+}

package/dist/plugins/slack-webhook/index.js

@@ -0,0 +1,51 @@
+import { parseSlackWebhookPayload, SLACK_WEBHOOK_PROVIDER } from '../../app/slack-webhook.js';
+/**
+ * Handles `action:webhook` for the Slack Events API: URL verification challenges and
+ * `message` events transformed into `agent:invoke` turns.
+ */
+export const slackWebhookPlugin = {
+    id: 'slack-webhook',
+    name: 'Slack webhook',
+    description: 'Parses inbound Slack Events API webhooks and forwards user messages to the runtime.',
+    factory: ({ agentId }) => (builder) => {
+        builder.on('action:webhook', async function* (event) {
+            if (event.data?.provider !== SLACK_WEBHOOK_PROVIDER)
+                return;
+            const rawBody = Buffer.from(event.data.rawBody, 'base64');
+            const parsed = parseSlackWebhookPayload(rawBody);
+            if (!parsed)
+                return;
+            if (parsed.kind === 'url_verification') {
+                yield {
+                    type: 'action:webhook:http-response',
+                    data: {
+                        status: 200,
+                        body: { challenge: parsed.challenge },
+                    },
+                };
+                return;
+            }
+            if (parsed.kind === 'ignored') {
+                yield {
+                    type: 'action:webhook:http-response',
+                    data: { status: 200, body: { ok: true, ignored: parsed.reason } },
+                };
+                return;
+            }
+            const userLabel = parsed.userId ? `<@${parsed.userId}>` : 'Slack user';
+            yield {
+                type: 'agent:invoke',
+                data: {
+                    role: 'user',
+                    content: `${userLabel}: ${parsed.text}`,
+                },
+                meta: {
+                    agentId,
+                    slackChannelId: parsed.slackChannelId,
+                    slackThreadTs: parsed.threadTs,
+                    slackUserId: parsed.userId,
+                },
+            };
+        });
+    },
+};

package/dist/plugins/storage/index.js

@@ -43,7 +43,8 @@ export const storagePlugin = {
         });
         builder.on('agent:usage', async function* (event, context) {
             const { usage } = event.data;
-            if (!context.state.threadId)
+            const channelId = context.state.channelId;
+            if (!channelId || !context.state.threadId)
                 return;
             const currentState = context.state.threadDetails?.state || {};
             const currentUsage = currentState.usage || {
@@ -57,12 +58,12 @@ export const storagePlugin = {
                 totalTokens: (currentUsage.totalTokens || 0) + usage.totalTokens,
             };
             await storage.patchThreadState({
-                channelId: context.state.channelId,
+                channelId,
                 threadId: context.state.threadId,
                 state: { usage: nextUsage },
             });
             context.state.threadDetails = await storage.getThreadDetails({
-                channelId: context.state.channelId,
+                channelId,
                 threadId: context.state.threadId,
             });
         });
@@ -76,9 +77,17 @@ export const storagePlugin = {
         });
         builder.on('action:storage:set-last-read', async function* (event, context) {
             const { channelId, threadId, lastReadEventId } = event.data;
+            const resolvedChannelId = channelId || context.state.channelId;
+            if (!resolvedChannelId) {
+                yield {
+                    type: 'action:storage:set-last-read-result',
+                    data: { success: false, error: 'channelId is required' },
+                };
+                return;
+            }
             try {
                 await storage.setLastRead({
-                    channelId: channelId || context.state.channelId,
+                    channelId: resolvedChannelId,
                     threadId: threadId || context.state.threadId,
                     lastReadEventId,
                 });
@@ -95,15 +104,29 @@ export const storagePlugin = {
             }
         });
         builder.on('action:storage:get-channel-details', async function* (_, state) {
-            const channelDetails = await storage.getChannelDetails({
-                channelId: state.state.channelId,
-            });
+            const channelId = state.state.channelId;
+            if (!channelId) {
+                yield {
+                    type: 'action:storage:get-channel-details-result',
+                    data: { channelDetails: null, error: 'channelId is required' },
+                };
+                return;
+            }
+            const channelDetails = await storage.getChannelDetails({ channelId });
             yield { type: 'action:storage:get-channel-details-result', data: { channelDetails } };
         });
         builder.on('action:storage:get-thread-details', async function* (_, state) {
+            const channelId = state.state.channelId;
             const threadId = state.state.threadId;
+            if (!channelId) {
+                yield {
+                    type: 'action:storage:get-thread-details-result',
+                    data: { threadDetails: null, error: 'channelId is required' },
+                };
+                return;
+            }
             const threadDetails = threadId
-                ? await storage.getThreadDetails({ channelId: state.state.channelId, threadId })
+                ? await storage.getThreadDetails({ channelId, threadId })
                 : null;
             yield { type: 'action:storage:get-thread-details-result', data: { threadDetails } };
         });
@@ -210,7 +233,12 @@ export const storagePlugin = {
             }
         });
         builder.on('action:storage:get-events', async function* (_, state) {
-            const events = await storage.getEvents(state.state);
+            const channelId = state.state.channelId;
+            if (!channelId) {
+                yield { type: 'action:storage:get-events-result', data: { events: [] } };
+                return;
+            }
+            const events = await storage.getEvents({ channelId, threadId: state.state.threadId });
             yield { type: 'action:storage:get-events-result', data: { events } };
         });
         builder.on('action:storage:get-variables', async function* () {
@@ -261,9 +289,14 @@ export const storagePlugin = {
             }
         });
         builder.on('action:storage:patch-channel-state', async function* (event, state) {
+            const channelId = state.state.channelId;
+            if (!channelId) {
+                yield { type: 'action:storage:patch-channel-state-result', data: { success: false } };
+                return;
+            }
             try {
                 await storage.patchChannelState({
-                    channelId: state.state.channelId,
+                    channelId,
                     state: event.data.state,
                 });
                 yield { type: 'action:storage:patch-channel-state-result', data: { success: true } };
@@ -273,12 +306,13 @@ export const storagePlugin = {
             }
         });
         builder.on('action:storage:patch-thread-state', async function* (event, state) {
+            const channelId = state.state.channelId;
             try {
-                if (!state.state.threadId) {
-                    throw new Error('Missing threadId in state for patch-thread-state');
+                if (!channelId || !state.state.threadId) {
+                    throw new Error('Missing channelId or threadId in state for patch-thread-state');
                 }
                 await storage.patchThreadState({
-                    channelId: state.state.channelId,
+                    channelId,
                     threadId: state.state.threadId,
                     state: event.data.state,
                 });
@@ -291,6 +325,13 @@ export const storagePlugin = {
         builder.on('action:storage:list-files', async function* (event, context) {
             const channelId = context.state.channelId;
             const subPath = event.data?.path || '';
+            if (!channelId) {
+                yield {
+                    type: 'action:storage:list-files:result',
+                    data: { success: false, files: [], error: 'channelId is required' },
+                };
+                return;
+            }
             try {
                 const files = await storage.listFiles({ channelId, path: subPath });
                 yield {
@@ -321,6 +362,13 @@ export const storagePlugin = {
                 };
                 return;
             }
+            if (!channelId) {
+                yield {
+                    type: 'action:storage:read-file:result',
+                    data: { success: false, path: filePath, error: 'channelId is required' },
+                };
+                return;
+            }
             try {
                 if (encoding === 'utf8') {
                     const content = await storage.readFile({ channelId, path: filePath });
@@ -361,8 +409,18 @@ export const storagePlugin = {
                 };
                 return;
             }
+            if (!channelId) {
+                yield {
+                    type: 'action:storage:get-file-url:result',
+                    data: { success: false, path: filePath, error: 'channelId is required' },
+                };
+                return;
+            }
             try {
-                const { size, mimeType } = await storage.getChannelFileStat({ channelId, path: filePath });
+                const { size, mimeType } = await storage.getChannelFileStat({
+                    channelId,
+                    path: filePath,
+                });
                 const url = buildWorkspaceFileUrl({
                     baseUrl: resolvePublicBaseUrl(),
                     channelId,

package/dist/plugins/storage/service.js

@@ -9,7 +9,7 @@ import crypto from 'node:crypto';
 import matter from 'gray-matter';
 import { OPENBOT_PLUGIN_ID } from '../../app/openbot-plugin.js';
 import { listBuiltInPlugins, parsePluginModule } from '../../services/plugins/registry.js';
-import { enrichOpenbotPluginDescriptor, listRegistryModelOptions, } from '../../services/plugins/model-registry.js';
+import { enrichOpenbotPluginDescriptor } from '../../services/plugins/enrich-openbot-plugin.js';
 import { processService } from '../../services/process.js';
 import { memoryService } from '../memory/service.js';
 import { guessMimeType, resolveChannelFile, statChannelFile } from './files.js';
@@ -837,13 +837,12 @@ export const storageService = {
         return Array.from(deduped.values()).filter((agent) => !agent.hidden);
     },
     getPlugins: async () => {
-        const [builtIn, fromDisk, modelOptions] = await Promise.all([
+        const [builtIn, fromDisk] = await Promise.all([
             listBuiltInPluginDescriptors(),
             listPluginsFromDisk(),
-            listRegistryModelOptions(),
         ]);
-        const enrichedBuiltIn = builtIn.map((plugin) => enrichOpenbotPluginDescriptor(plugin, modelOptions));
-        const merged = [...enrichedBuiltIn, ...fromDisk];
+        const enrichPlugin = (plugin) => enrichOpenbotPluginDescriptor(plugin);
+        const merged = [...builtIn.map(enrichPlugin), ...fromDisk.map(enrichPlugin)];
         const deduped = new Map();
         for (const plugin of merged) {
             if (!deduped.has(plugin.id)) {
@@ -1361,7 +1360,13 @@ export const storageService = {
      * Hydrates the full OpenBot state from disk/storage before a run.
      */
     getOpenBotState: async (options) => {
-        const { runId, agentId, channelId, threadId, event } = options;
+        const { runId, agentId, event } = options;
+        const channelId = typeof event.meta?.channelId === 'string'
+            ? event.meta.channelId.trim() || undefined
+            : undefined;
+        const threadId = typeof event.meta?.threadId === 'string'
+            ? event.meta.threadId.trim() || undefined
+            : undefined;
         let agentDetails;
         try {
             agentDetails = await storageService.getAgentDetails({ agentId });

package/dist/services/plugins/enrich-openbot-plugin.js

@@ -0,0 +1,38 @@
+import { OPENBOT_PLUGIN_ID } from '../../app/openbot-plugin.js';
+import { DEFAULT_CLOUD_OPENBOT_AUTH_MODE, isCloudMode } from '../../app/cloud-mode.js';
+/** Injects cloud platform fields into the openbot plugin descriptor for settings UI. */
+export function enrichOpenbotPluginDescriptor(descriptor) {
+    if (descriptor.id !== OPENBOT_PLUGIN_ID || !descriptor.configSchema)
+        return descriptor;
+    if (!isCloudMode())
+        return descriptor;
+    const { authMode: _authMode, ...otherProperties } = descriptor.configSchema.properties;
+    const cloudAuthModeProperty = {
+        type: 'string',
+        description: 'Credits uses OpenBot platform billing. BYOK uses your own API keys.',
+        enum: ['credits', 'byok'],
+        default: DEFAULT_CLOUD_OPENBOT_AUTH_MODE,
+        options: [
+            {
+                label: 'Credits',
+                value: 'credits',
+                description: 'Use OpenBot platform credits.',
+            },
+            {
+                label: 'Bring your own key',
+                value: 'byok',
+                description: 'Use your own provider API keys.',
+            },
+        ],
+    };
+    return {
+        ...descriptor,
+        configSchema: {
+            ...descriptor.configSchema,
+            properties: {
+                authMode: cloudAuthModeProperty,
+                ...otherProperties,
+            },
+        },
+    };
+}

package/dist/services/plugins/host.js

@@ -2,15 +2,12 @@ import { DEFAULT_CLOUD_OPENBOT_AUTH_MODE, isCloudMode, isCloudSystemAgent, parse
 import { ORCHESTRATOR_AGENT_ID } from '../../app/agent-ids.js';
 import { OPENBOT_PLUGIN_ID } from '../../app/openbot-plugin.js';
 import { getBaseDir, resolvePath, saveConfig } from '../../app/config.js';
-import { listApiKeyProvidersFromRegistry, resolveModelRegistry, } from './model-registry.js';
 export function createPluginHost(runAgent) {
     return {
         runAgent,
         isCloudSystemAgent,
         isCloudMode,
         parseOpenbotAuthMode,
-        resolveModelRegistry,
-        listApiKeyProvidersFromRegistry,
         saveConfig,
         getBaseDir,
         resolvePath,

package/dist/services/plugins/model-registry.js

@@ -74,7 +74,7 @@ export function enrichOpenbotPluginDescriptor(descriptor, modelOptions) {
         : pickDefaultModelValue(modelOptions) ?? staticDefault;
     const nextModelProperty = {
         ...modelProperty,
-        description: 'Model from the hosted marketplace registry.',
+        description: modelProperty.description ?? 'Model from the hosted marketplace registry.',
     };
     if (values.length > 0) {
         nextModelProperty.enum = values;

package/docs/plugins.md

@@ -60,6 +60,33 @@ model as the tool result (`history.ts`). Structured fields (e.g. `list`,
 | `todo`           | Tool    | `todo_write`, `todo_read` (inbuilt in `openbot`)              |
 | `plugin-manager` | Infra   | Marketplace list, npm plugin install/uninstall, agent install |
 
+## Inbound webhooks
+
+`POST /api/webhooks/:provider` forwards third-party HTTP payloads onto the bus as
+`action:webhook`. The URL segment is used as the target agent id when
+`~/.openbot/agents/<provider>/AGENT.md` exists; otherwise the request falls back
+to the `system` agent. Attach a plugin to the routed agent and handle
+verification, channel/thread routing, transforms, and HTTP responses there.
+
+```ts
+builder.on('action:webhook', async function* (event) {
+  if (event.data?.provider !== 'slack') return;
+
+  const rawBody = Buffer.from(event.data.rawBody, 'base64');
+
+  // Optional: control the HTTP response (URL challenges, 401s, custom acks)
+  yield {
+    type: 'action:webhook:http-response',
+    data: { status: 200, body: { ok: true } },
+  };
+
+  yield {
+    type: 'agent:invoke',
+    data: { role: 'user', content: '...' },
+  };
+});
+```
+
 ## Batteries-included: `openbot` runtime
 
 The `openbot` plugin is the standard runtime for OpenBot agents. It is designed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbot",
-  "version": "0.5.8",
+  "version": "0.5.10",
   "private": false,
   "type": "module",
   "engines": {
@@ -11,7 +11,7 @@
     "build": "tsc && mkdir -p dist/assets && cp src/assets/icon.svg dist/assets/icon.svg",
     "start": "node dist/app/cli.js start",
     "format": "prettier --write .",
-    "push": "fly deploy --build-only --push --config deploy/fly.toml -a openbot-runtime --image-label v0.5.8"
+    "push": "fly deploy --build-only --push --config deploy/fly.toml -a openbot-runtime --image-label v0.5.10"
   },
   "bin": {
     "openbot": "./dist/app/cli.js"

package/src/app/active-runs.ts

@@ -0,0 +1,95 @@
+import { ActiveRunsSnapshotEvent } from './types.js';
+
+export type ActiveRunRecord = {
+  runId: string;
+  channelId: string;
+  threadId?: string;
+  agentId: string;
+};
+
+type Bucket = {
+  channelId: string;
+  threadId?: string;
+  activeCount: number;
+  agentIds: Set<string>;
+};
+
+export function getRunKey(
+  runId: string,
+  agentId: string,
+  channelId: string,
+  threadId?: string,
+): string {
+  return `${runId}:${agentId}:${channelId}:${threadId || ''}`;
+}
+
+export class ActiveRunsTracker {
+  private runs = new Map<string, ActiveRunRecord>();
+
+  trackStart(data: ActiveRunRecord): void {
+    this.runs.set(getRunKey(data.runId, data.agentId, data.channelId, data.threadId), data);
+  }
+
+  trackEnd(data: ActiveRunRecord): void {
+    this.runs.delete(getRunKey(data.runId, data.agentId, data.channelId, data.threadId));
+  }
+
+  buildSnapshot(): ActiveRunsSnapshotEvent {
+    const byBucket = new Map<string, Bucket>();
+    for (const run of this.runs.values()) {
+      const threadId = run.threadId || undefined;
+      const key = JSON.stringify([run.channelId, threadId ?? null]);
+      let bucket = byBucket.get(key);
+      if (!bucket) {
+        bucket = {
+          channelId: run.channelId,
+          threadId,
+          activeCount: 0,
+          agentIds: new Set<string>(),
+        };
+        byBucket.set(key, bucket);
+      }
+      bucket.activeCount += 1;
+      bucket.agentIds.add(run.agentId);
+    }
+    const channels = Array.from(byBucket.values())
+      .sort((a, b) => {
+        const c = a.channelId.localeCompare(b.channelId);
+        if (c !== 0) return c;
+        return (a.threadId ?? '').localeCompare(b.threadId ?? '');
+      })
+      .map(({ channelId, threadId, activeCount, agentIds }) => {
+        const row: ActiveRunsSnapshotEvent['data']['channels'][number] = {
+          channelId,
+          activeCount,
+          agentIds: Array.from(agentIds),
+        };
+        if (threadId !== undefined) {
+          row.threadId = threadId;
+        }
+        return row;
+      });
+    return {
+      type: 'agent:active-runs:snapshot',
+      data: { channels },
+    };
+  }
+
+  /**
+   * Drop every tracked run for a channel/thread. Returns the purged records so
+   * callers can emit synthetic `agent:run:end` events to SSE clients.
+   */
+  purgeForThread(channelId: string, threadId?: string): ActiveRunRecord[] {
+    const target = threadId || undefined;
+    const removed: ActiveRunRecord[] = [];
+
+    for (const [key, run] of this.runs) {
+      if (run.channelId === channelId && (run.threadId || undefined) === target) {
+        removed.push(run);
+        this.runs.delete(key);
+      }
+    }
+
+    return removed;
+  }
+}

package/src/app/cli.ts

@@ -27,7 +27,7 @@ function checkNodeVersion() {
 
 checkNodeVersion();
 
-program.name('openbot').description('OpenBot CLI').version('0.5.8');
+program.name('openbot').description('OpenBot CLI').version('0.5.10');
 
 program
   .command('start')

package/src/app/lifecycle-events.ts

@@ -0,0 +1,46 @@
+import { storageService } from '../plugins/storage/service.js';
+import { OpenBotEvent } from './types.js';
+import { ensureEventId } from './utils.js';
+
+export function persistLifecycleEvent(
+  event: OpenBotEvent,
+  targetChannelId: string,
+  targetThreadId?: string,
+): void {
+  ensureEventId(event);
+  storageService
+    .storeEvent({
+      channelId: targetChannelId,
+      threadId: targetThreadId,
+      event,
+    })
+    .catch((error) => {
+      console.error('[server] Failed to persist lifecycle event', {
+        type: event.type,
+        channelId: targetChannelId,
+        threadId: targetThreadId,
+        error,
+      });
+    });
+}
+
+export type LifecycleBroadcastDeps = {
+  sendToClientKey: (clientKey: string, event: OpenBotEvent) => void;
+  getClientKey: (channelId: string, threadId?: string) => string;
+  globalChannelId: string;
+};
+
+export function broadcastLifecycleEvent(
+  event: OpenBotEvent,
+  channelId: string,
+  threadId: string | undefined,
+  deps: LifecycleBroadcastDeps,
+  options?: { persist?: boolean },
+): void {
+  ensureEventId(event);
+  if (options?.persist !== false) {
+    persistLifecycleEvent(event, channelId, threadId);
+  }
+  deps.sendToClientKey(deps.getClientKey(channelId, threadId), event);
+  deps.sendToClientKey(deps.globalChannelId, event);
+}