@capybara-hq/kernel 0.1.0-rc.1 → 0.1.0-rc.11

package/dist/roles/worker.module.js

@@ -0,0 +1,106 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var WorkerModule_1;
+import { Module } from "@nestjs/common";
+import { BackgroundModule } from "../background/background.module.js";
+import { BackgroundTaskPollJob } from "../background/poll.job.js";
+import { CatalogModule } from "../catalog/catalog.module.js";
+import { CatalogJobs } from "../catalog/jobs.js";
+import { PlatformMigration } from "../catalog/platform-migration.js";
+import { PluginScopeWorkersModule } from "../catalog/scope-sync-workers.js";
+import { ChannelsModule, ChannelWorkersModule } from "../channels/channels.module.js";
+import { GatewayCheckJob } from "../channels/supervisor.js";
+import { AttachmentsModule } from "../conversations/attachments.module.js";
+import { AttachmentCleanupJob } from "../conversations/attachments.service.js";
+import { EventLogModule } from "../conversations/event-log.js";
+import { TitlesModule } from "../conversations/titles.js";
+import { LegacySandboxCleanupJob } from "../environments/legacy-cleanup.job.js";
+import { EvalWorkersModule } from "../evals/evals.module.js";
+import { ExtensionsModule } from "../extensions/extensions.module.js";
+import { PluginsReconcileJob } from "../extensions/lifecycle.js";
+import { InitialPasswordCleanupJob } from "../identity/initial-passwords.job.js";
+import { KernelScheduleModule } from "../infra/schedule/schedule.module.js";
+import { DirectoryScanJob } from "../orgs/directory-sync.js";
+import { OffboardSweepJob } from "../orgs/offboarding.js";
+import { OrgLockModule } from "../orgs/org-lock.js";
+import { OrgsModule } from "../orgs/orgs.module.js";
+import { MaintenanceModule } from "../runtime/maintenance.js";
+import { RuntimeWorkersModule } from "../runtime/run-processors.js";
+import { RuntimeModule } from "../runtime/runtime.module.js";
+import { UsageReportModule, UsageSweepJob } from "../runtime/usage-report.js";
+import { WaitSweepJob } from "../runtime/waits.js";
+import { SandboxSweepJobs } from "../sandbox/jobs.js";
+import { SandboxModule } from "../sandbox/sandbox.module.js";
+import { StoragePurgeJob } from "../storage/purge.js";
+import { StorageModule } from "../storage/storage.module.js";
+import { ToolJobs } from "../tools/jobs.js";
+import { ToolsModule } from "../tools/tools.module.js";
+import { WorkerRole } from "./worker-role.js";
+/**
+ * The worker role (nest kernel spec §2), imported by `KernelModule` only when `roles` includes
+ * `worker`: the cron scheduler and the `@LockedInterval` scheduler (`KernelScheduleModule`, the one
+ * place `ScheduleModule.forRoot` is imported), every fixed-period job (`@LockedCron` /
+ * `@LockedInterval`, each once per tick across replicas), every queue consumer (`@Processor`: runs,
+ * sub-agent runs, `usage.report`, titles, evals, maintenance, channel deliveries, the plugin scope sync) and
+ * {@link WorkerRole}, which `KernelLifecycle` drives. A process without the worker role runs no cron
+ * and no BullMQ worker (the queues' producers exist on every role).
+ */
+let WorkerModule = WorkerModule_1 = class WorkerModule {
+    static forRoot(config) {
+        return {
+            module: WorkerModule_1,
+            imports: [
+                KernelScheduleModule,
+                // the queue consumers (their worker options come from the startup config)
+                RuntimeWorkersModule.forRoot(config),
+                EvalWorkersModule.forRoot(config),
+                ChannelWorkersModule.forRoot(config),
+                MaintenanceModule,
+                PluginScopeWorkersModule,
+                // the domains the fixed-period jobs call
+                RuntimeModule,
+                UsageReportModule,
+                TitlesModule,
+                AttachmentsModule,
+                StorageModule,
+                SandboxModule,
+                BackgroundModule,
+                EventLogModule,
+                ToolsModule,
+                CatalogModule,
+                OrgsModule,
+                OrgLockModule,
+                ExtensionsModule,
+                ChannelsModule,
+            ],
+            providers: [
+                WaitSweepJob,
+                UsageSweepJob,
+                AttachmentCleanupJob,
+                StoragePurgeJob,
+                SandboxSweepJobs,
+                LegacySandboxCleanupJob,
+                BackgroundTaskPollJob,
+                ToolJobs,
+                InitialPasswordCleanupJob,
+                CatalogJobs,
+                PlatformMigration,
+                DirectoryScanJob,
+                OffboardSweepJob,
+                PluginsReconcileJob,
+                GatewayCheckJob,
+                WorkerRole,
+            ],
+            exports: [WorkerRole],
+        };
+    }
+};
+WorkerModule = WorkerModule_1 = __decorate([
+    Module({})
+    // biome-ignore lint/complexity/noStaticOnlyClass: a Nest dynamic module
+], WorkerModule);
+export { WorkerModule };

package/dist/runtime/abort.js

@@ -1,3 +1,14 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { KERNEL_BUS, REDIS } from "../infra/tokens.js";
 /** 中止广播的内核 bus 主题。 */
 export const RUN_ABORT_TOPIC = "run.abort";
 /** 中止标记的保留时长（秒）。 */
@@ -15,7 +26,7 @@ const parseStored = (stored) => {
  * 跨副本中止（spec 4.3「中止信号经 Redis 广播」）：`request` 先写标记键再广播；
  * `watch` 先订阅、再检查一次标记键，订阅之前发出的中止也不会丢。
  */
-export class RunAbort {
+let RunAbort = class RunAbort {
     redis;
     bus;
     constructor(redis, bus) {
@@ -68,4 +79,10 @@ export class RunAbort {
         }
         return unsubscribe;
     }
-}
+};
+RunAbort = __decorate([
+    Injectable(),
+    __param(0, Inject(REDIS)),
+    __param(1, Inject(KERNEL_BUS))
+], RunAbort);
+export { RunAbort };

package/dist/runtime/checkpointer.d.ts

@@ -1,6 +1,7 @@
 import type { RunnableConfig } from "@langchain/core/runnables";
 import { BaseCheckpointSaver, type ChannelVersions, type Checkpoint, type CheckpointListOptions, type CheckpointMetadata, type CheckpointTuple, type PendingWrite } from "@langchain/langgraph-checkpoint";
-import type { KernelDb } from "../db/kernel-schema.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
 /**
  * LangGraph checkpoint saver，存在内核 schema 的 `lg_checkpoints` / `lg_checkpoint_writes` 里（0007_checkpoints.sql）。
  *
@@ -10,12 +11,16 @@ import type { KernelDb } from "../db/kernel-schema.js";
  * - 所有状态都在 PG 里，不持有进程内状态，任意副本都能续跑。
  */
 export declare class KyselyCheckpointSaver extends BaseCheckpointSaver {
-    private readonly db;
-    constructor(db: KernelDb);
+    private readonly kdb;
+    readonly txHost: TransactionHost;
+    constructor(kdb: KernelDb, txHost: TransactionHost);
+    /** The context's handle (the transaction of a `@Transactional` method, else the pool). */
+    private get db();
     getTuple(config: RunnableConfig): Promise<CheckpointTuple | undefined>;
     list(config: RunnableConfig, options?: CheckpointListOptions): AsyncGenerator<CheckpointTuple>;
     put(config: RunnableConfig, checkpoint: Checkpoint, metadata: CheckpointMetadata, _newVersions: ChannelVersions): Promise<RunnableConfig>;
     putWrites(config: RunnableConfig, writes: PendingWrite[], taskId: string, taskPath?: string): Promise<void>;
+    private insertWrites;
     deleteThread(threadId: string): Promise<void>;
     /**
      * 一轮运行结束后调用：根命名空间（`checkpoint_ns = ''`）下只保留最新一个 checkpoint 及其 writes，

package/dist/runtime/checkpointer.js

@@ -1,5 +1,18 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
 import { BaseCheckpointSaver, compareWritesSortKeys, copyCheckpoint, getCheckpointId, maxChannelVersion, TASKS, WRITES_IDX_MAP, writesSortKey, } from "@langchain/langgraph-checkpoint";
+import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { Transactional } from "../infra/database/transactional.decorator.js";
 const CHECKPOINT_COLUMNS = [
     "thread_id",
     "checkpoint_ns",
@@ -20,11 +33,17 @@ const idC = sql `checkpoint_id collate "C"`;
  * - thread_id 约定为 runId。
  * - 所有状态都在 PG 里，不持有进程内状态，任意副本都能续跑。
  */
-export class KyselyCheckpointSaver extends BaseCheckpointSaver {
-    db;
-    constructor(db) {
+let KyselyCheckpointSaver = class KyselyCheckpointSaver extends BaseCheckpointSaver {
+    kdb;
+    txHost;
+    constructor(kdb, txHost) {
         super();
-        this.db = db;
+        this.kdb = kdb;
+        this.txHost = txHost;
+    }
+    /** The context's handle (the transaction of a `@Transactional` method, else the pool). */
+    get db() {
+        return this.kdb.db;
     }
     async getTuple(config) {
         const threadId = config.configurable?.thread_id;
@@ -130,34 +149,33 @@ export class KyselyCheckpointSaver extends BaseCheckpointSaver {
         // 特殊 channel（错误、中断等，idx < 0）以最后一次为准；普通 write 已存在则保留先写入的。
         const special = rows.filter((r) => r.idx < 0);
         const regular = rows.filter((r) => r.idx >= 0);
+        await this.insertWrites(regular, special);
+    }
+    async insertWrites(regular, special) {
         const key = ["thread_id", "checkpoint_ns", "checkpoint_id", "task_id", "idx"];
-        await this.db.transaction().execute(async (trx) => {
-            if (regular.length > 0) {
-                await trx
-                    .insertInto("lg_checkpoint_writes")
-                    .values(regular)
-                    .onConflict((oc) => oc.columns(key).doNothing())
-                    .execute();
-            }
-            if (special.length > 0) {
-                await trx
-                    .insertInto("lg_checkpoint_writes")
-                    .values(special)
-                    .onConflict((oc) => oc.columns(key).doUpdateSet((eb) => ({
-                    channel: eb.ref("excluded.channel"),
-                    value_type: eb.ref("excluded.value_type"),
-                    value: eb.ref("excluded.value"),
-                    task_path: eb.ref("excluded.task_path"),
-                })))
-                    .execute();
-            }
-        });
+        if (regular.length > 0) {
+            await this.db
+                .insertInto("lg_checkpoint_writes")
+                .values(regular)
+                .onConflict((oc) => oc.columns(key).doNothing())
+                .execute();
+        }
+        if (special.length > 0) {
+            await this.db
+                .insertInto("lg_checkpoint_writes")
+                .values(special)
+                .onConflict((oc) => oc.columns(key).doUpdateSet((eb) => ({
+                channel: eb.ref("excluded.channel"),
+                value_type: eb.ref("excluded.value_type"),
+                value: eb.ref("excluded.value"),
+                task_path: eb.ref("excluded.task_path"),
+            })))
+                .execute();
+        }
     }
     async deleteThread(threadId) {
-        await this.db.transaction().execute(async (trx) => {
-            await trx.deleteFrom("lg_checkpoint_writes").where("thread_id", "=", threadId).execute();
-            await trx.deleteFrom("lg_checkpoints").where("thread_id", "=", threadId).execute();
-        });
+        await this.db.deleteFrom("lg_checkpoint_writes").where("thread_id", "=", threadId).execute();
+        await this.db.deleteFrom("lg_checkpoints").where("thread_id", "=", threadId).execute();
     }
     /**
      * 一轮运行结束后调用：根命名空间（`checkpoint_ns = ''`）下只保留最新一个 checkpoint 及其 writes，
@@ -166,31 +184,30 @@ export class KyselyCheckpointSaver extends BaseCheckpointSaver {
      * 保留下来的 checkpoint 的 parent_checkpoint_id 原样保留（父 checkpoint 已不存在）。
      */
     async pruneToLatest(threadId) {
-        return this.db.transaction().execute(async (trx) => {
-            const latest = await trx
-                .selectFrom("lg_checkpoints")
-                .select("checkpoint_id")
-                .where("thread_id", "=", threadId)
-                .where("checkpoint_ns", "=", "")
-                .orderBy(sql `${idC} desc`)
-                .limit(1)
-                .executeTakeFirst();
-            if (!latest)
-                return 0;
-            await trx
-                .deleteFrom("lg_checkpoint_writes")
-                .where("thread_id", "=", threadId)
-                .where("checkpoint_ns", "=", "")
-                .where(idC, "<", latest.checkpoint_id)
-                .execute();
-            const res = await trx
-                .deleteFrom("lg_checkpoints")
-                .where("thread_id", "=", threadId)
-                .where("checkpoint_ns", "=", "")
-                .where(idC, "<", latest.checkpoint_id)
-                .executeTakeFirst();
-            return Number(res.numDeletedRows);
-        });
+        const db = this.db;
+        const latest = await db
+            .selectFrom("lg_checkpoints")
+            .select("checkpoint_id")
+            .where("thread_id", "=", threadId)
+            .where("checkpoint_ns", "=", "")
+            .orderBy(sql `${idC} desc`)
+            .limit(1)
+            .executeTakeFirst();
+        if (!latest)
+            return 0;
+        await db
+            .deleteFrom("lg_checkpoint_writes")
+            .where("thread_id", "=", threadId)
+            .where("checkpoint_ns", "=", "")
+            .where(idC, "<", latest.checkpoint_id)
+            .execute();
+        const res = await db
+            .deleteFrom("lg_checkpoints")
+            .where("thread_id", "=", threadId)
+            .where("checkpoint_ns", "=", "")
+            .where(idC, "<", latest.checkpoint_id)
+            .executeTakeFirst();
+        return Number(res.numDeletedRows);
     }
     async toTuple(row, metadata) {
         const { thread_id, checkpoint_ns, checkpoint_id, parent_checkpoint_id } = row;
@@ -240,4 +257,19 @@ export class KyselyCheckpointSaver extends BaseCheckpointSaver {
         checkpoint.channel_versions[TASKS] =
             versions.length > 0 ? maxChannelVersion(...versions) : this.getNextVersion(undefined);
     }
-}
+};
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], KyselyCheckpointSaver.prototype, "insertWrites", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], KyselyCheckpointSaver.prototype, "deleteThread", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], KyselyCheckpointSaver.prototype, "pruneToLatest", null);
+KyselyCheckpointSaver = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(TransactionHost))
+], KyselyCheckpointSaver);
+export { KyselyCheckpointSaver };

package/dist/runtime/context/build.d.ts

@@ -1,6 +1,6 @@
 import { type ContentBlock, type ModelInfo, type ModelRequest, type ParamValue } from "@capybara-hq/plugin-sdk";
 import type { AgentDefinition } from "../../agents/definition.js";
-import type { ConversationEvent, EventPayload } from "../../conversations/events.js";
+import { type ConversationEvent, type EventPayload } from "../../conversations/events.js";
 import type { ResolvedTool } from "../../tools/registry.js";
 /**
  * 平台行为规范（模型可见，英文）。短而通用（spec 6 原则 5）；不放时间戳、会话 ID 等会变化的内容，
@@ -25,13 +25,13 @@ export interface ModelCallMeta {
     params: Record<string, ParamValue>;
     /**
      * 请求带的工具（按发送顺序）及定义指纹；定义本身按指纹存在 `capybara.tool_specs`。
-     * 未启用 tool_search 时按 key 排序；启用时见 {@link BuildModelRequestInput.toolSearch}。
+     * 未启用 ToolSearch 时按 key 排序；启用时见 {@link BuildModelRequestInput.toolSearch}。
      */
     tools: {
         key: string;
         specHash: string;
     }[];
-    /** 启用 tool_search 时 system 第二块目录里的工具（按 key 排序）及定义指纹；未启用没有该字段。 */
+    /** 启用 ToolSearch 时 system 第二块目录里的工具（按 key 排序）及定义指纹；未启用没有该字段。 */
     catalog?: {
         key: string;
         specHash: string;
@@ -54,13 +54,14 @@ export interface BuildModelRequestInput {
     model: ModelInfo;
     step: number;
     /**
-     * loop 已吸收到的 user_message seq（R31）。提供时：
-     * - seq 大于它的 user_message 不进请求（运行中途到达、尚未被吸收的插话，由后续步骤吸收或触发下一轮）；
-     * - 每条 user_message 放在**吸收它的那次模型调用**的位置：日志里第一个 `request.absorbedUpToSeq`
+     * loop 已吸收到的位置（R31）：the largest seq of the absorbable events (`user_message`,
+     * `background_task_finished` and `subagent_delivery`, {@link isAbsorbable}) the loop took. 提供时：
+     * - seq 大于它的可吸收事件不进请求（运行中途到达、尚未被吸收的插话或后台任务结束，由后续步骤吸收或触发下一轮）；
+     * - 每个可吸收事件放在**吸收它的那次模型调用**的位置：日志里第一个 `request.absorbedUpToSeq`
      *   不小于它的 `model_call` 之前（没有该字段的旧 model_call 视为吸收了它之前的全部消息），
      *   本次请求吸收的放在末尾。于是模型看到的历史只追加（插话不会插到已发送的回复之前），
      *   且请求可由日志 + `model_call` 精确还原。
-     * 不提供时按 seq 原样回放全部 user_message。
+     * 不提供时按 seq 原样回放全部可吸收事件。
      */
     absorbedUpToSeq?: number;
     /**
@@ -75,8 +76,8 @@ export interface BuildModelRequestInput {
      */
     tools?: RequestTool[];
     /**
-     * 启用 tool_search（spec 5.5，由 `ToolRegistry.forAgent` 判定）。启用且有工具时：
-     * - `tools` 只放内置工具（含 `tool_search`，按 key 排序）与**已加载**工具的完整定义；
+     * 启用 ToolSearch（spec 5.5，由 `ToolRegistry.forAgent` 判定）。启用且有工具时：
+     * - `tools` 只放内置工具（含 `ToolSearch`，按 key 排序）与**已加载**工具的完整定义；
      *   已加载 = 日志中全部 `tool_result.loadedTools` 的并集（含摘要之前的；不在本步可用工具中的忽略），
      *   按首次加载顺序追加在内置工具之后——新加载只在末尾追加，已发送的工具顺序不变；
      * - 其余工具（不论是否已加载）以目录形式放进 system 第二个块（按 key 排序，打缓存断点），
@@ -224,17 +225,24 @@ export declare function summaryText(summary: string): string;
  * 由会话事件日志 + agent 定义构建模型请求（纯函数，不做 I/O）。
  * - system：`BEHAVIOR_RULES + "\n\n" + agent.instructions` 一个块，打缓存断点（a sub-agent's log:
  *   `BEHAVIOR_RULES`, its preamble and its instructions, all from its `subagent_started`）；日志里第一份 `skills_catalog`
- *   快照在任何 `model_call` 之前时，技能目录接在这个块末尾（Ruling M17，见 ./skills.ts）；启用 tool_search 时
+ *   快照在任何 `model_call` 之前时，技能目录接在这个块末尾（Ruling M17，见 ./skills.ts）；启用 ToolSearch 时
  *   第二个块是工具目录（见 {@link BuildModelRequestInput.toolSearch}）；
  * - 之后的 `skills_catalog` 在所在位置渲染为 system 变更提醒；被压缩摘要覆盖的，若摘要时生效的目录与 system 里的
  *   不同，紧随摘要补一条完整的当前目录；
  * - messages：最近一条摘要（若有）作为首条 user 消息，其后按 seq 回放 `coversUpToSeq` 之后的
  *   `user_message` / `assistant_message`（content 原样，含 opaque；aborted 的也回放；媒体引用按
  *   {@link resolveMedia} 换成 base64 或文字占位）/ `reminder`
- *   （`role: "system"`，放在它所在的位置）；`tool_result` 事件还原为紧随其 assistant 消息之后的一条 user 消息
+ *   （`role: "system"`，放在它所在的位置）/ `tools_changed` (`role: "system"`, the text of {@link toolsChangedText}, at its position) /
+ *   `environment_paths` (`role: "system"` at its position, `environmentPathsText`; covered by the
+ *   summary: the latest one follows the summary) /
+ *   `run_context` (`role: "system"` at its position, `runContextText`; covered by the summary: the
+ *   current context follows the summary whole; a user message's sender line by `senderLines`) /
+ *   `background_task_finished`（`role: "system"`, the text of
+ *   {@link renderBackgroundFinished}, placed like a user_message）/ `subagent_delivery` (likewise,
+ *   the text of {@link renderSubagentDelivery})；`tool_result` 事件还原为紧随其 assistant 消息之后的一条 user 消息
  *   （同一步的多个结果合并，按该 assistant 消息里 tool_call 的顺序；找不到对应调用的结果不进请求）。
  *   其他事件不进请求。提供 `absorbedUpToSeq` 时，
- *   尚未被吸收的 user_message 不进请求，运行中途到达的插话放在吸收它的调用处（见 BuildModelRequestInput）。
+ *   尚未被吸收的可吸收事件不进请求，运行中途到达的放在吸收它的调用处（见 BuildModelRequestInput）。
  * 只追加：新事件只会在 messages 末尾追加；唯一的前缀变化来自新的压缩摘要。
  * `step` 与 `agentVersion` 不进请求内容（保证缓存前缀稳定），由调用方写入 `model_call` 事件。
  */
@@ -245,7 +253,7 @@ export declare function buildModelRequest(input: BuildModelRequestInput): {
     mediaTokens: number;
 };
 /**
- * 日志里 `tool_search` 加载过的工具 key（全部 `tool_result.loadedTools` 的并集，按首次出现顺序）。
+ * 日志里 `ToolSearch` 加载过的工具 key（全部 `tool_result.loadedTools` 的并集，按首次出现顺序）。
  * 不看压缩摘要的边界：加载过的工具在摘要之后仍保持加载（模型可能凭摘要继续使用它们，且已发送的工具列表只追加）。
  */
 export declare function loadedToolKeys(events: readonly ConversationEvent[]): string[];