@keyou007/agent-bot 0.1.13-alpha.0 → 0.1.13-alpha.2

package/src/runtime/AcpRuntimeAdapter.ts

@@ -3,6 +3,7 @@ import { AcpSessionManager } from "../acp/AcpSessionManager.js";
 import { createId } from "../utils/id.js";
 import type {
   AgentRuntime,
+  AgentProcessInfo,
   ApprovalDecision,
   CreateRuntimeSessionInput,
   ModelOption,
@@ -37,6 +38,10 @@ export class AcpRuntimeAdapter implements AgentRuntime {
     return this.sessions.get(localSessionId);
   }
 
+  getProcessInfo(): AgentProcessInfo {
+    return this.acp.getProcessInfo();
+  }
+
   async createSession(input: CreateRuntimeSessionInput): Promise<RuntimeSession> {
     const created = await this.acp.create({
       localSessionId: input.localSessionId,

package/src/runtime/agentEnvironment.ts

@@ -2,13 +2,51 @@ export const AGENT_BOT_ENVIRONMENT = Object.freeze({
   AGENT_BOT: "1",
 });
 
+export interface AgentEnvironmentContext {
+  profilePath?: string;
+  configPath?: string;
+  agentName?: string;
+  larkAppId?: string;
+  larkBotOpenId?: string;
+  larkUserOpenId?: string;
+}
+
+const RESERVED_ENVIRONMENT_PREFIXES = ["AGENT_BOT_", "FEISHU_"];
+
 export function agentBotEnvironment(
   baseEnv: NodeJS.ProcessEnv,
   agentEnv: Record<string, string>,
+  context: AgentEnvironmentContext = {},
 ): NodeJS.ProcessEnv {
-  return {
-    ...baseEnv,
-    ...agentEnv,
+  const environment: NodeJS.ProcessEnv = {
+    ...withoutReservedEnvironment(baseEnv),
+    ...withoutReservedEnvironment(agentEnv),
     ...AGENT_BOT_ENVIRONMENT,
   };
+  setNonBlank(environment, "AGENT_BOT_HOME", context.profilePath);
+  setNonBlank(environment, "AGENT_BOT_CONFIG", context.configPath);
+  setNonBlank(environment, "AGENT_BOT_AGENT_NAME", context.agentName);
+  setNonBlank(environment, "AGENT_BOT_LARK_APP_ID", context.larkAppId);
+  setNonBlank(environment, "AGENT_BOT_LARK_BOT_OPEN_ID", context.larkBotOpenId);
+  setNonBlank(environment, "AGENT_BOT_LARK_USER_OPEN_ID", context.larkUserOpenId);
+  return environment;
+}
+
+function withoutReservedEnvironment(
+  environment: NodeJS.ProcessEnv | Record<string, string>,
+): NodeJS.ProcessEnv {
+  return Object.fromEntries(
+    Object.entries(environment).filter(([name, value]) =>
+      value !== undefined && !isReservedEnvironmentName(name)),
+  );
+}
+
+function isReservedEnvironmentName(name: string): boolean {
+  const normalized = name.toUpperCase();
+  return normalized === "AGENT_BOT"
+    || RESERVED_ENVIRONMENT_PREFIXES.some((prefix) => normalized.startsWith(prefix));
+}
+
+function setNonBlank(environment: NodeJS.ProcessEnv, name: string, value: string | undefined): void {
+  if (value?.trim()) environment[name] = value;
 }

package/src/runtime/createAgentRuntimeRegistry.ts

@@ -5,19 +5,34 @@ import { CodexProcessManager } from "../codex/CodexProcessManager.js";
 import { CodexRuntime } from "../codex/CodexRuntime.js";
 import type { AppConfig } from "../config/schema.js";
 import { AcpRuntimeAdapter } from "./AcpRuntimeAdapter.js";
+import type { AgentEnvironmentContext } from "./agentEnvironment.js";
 import { AgentRuntimeRegistry } from "./AgentRuntimeRegistry.js";
 import type { AgentRuntime } from "./types.js";
 
-export function createAgentRuntimeRegistry(config: AppConfig, logger: Logger): AgentRuntimeRegistry {
+export function createAgentRuntimeRegistry(
+  config: AppConfig,
+  logger: Logger,
+  environmentContext: AgentEnvironmentContext = {},
+): AgentRuntimeRegistry {
   const runtimes: Record<string, AgentRuntime> = {};
   for (const [agentName, agent] of Object.entries(config.agents)) {
     const runtimeLogger = logger.child({ agentName, runtimeKind: agent.kind });
+    const runtimeEnvironmentContext = (): AgentEnvironmentContext => ({
+      ...environmentContext,
+      agentName,
+    });
     if (agent.kind === "app-server") {
-      const processManager = new CodexProcessManager(agent.command, agent.args, agent.env, runtimeLogger);
+      const processManager = new CodexProcessManager(
+        agent.command,
+        agent.args,
+        agent.env,
+        runtimeLogger,
+        runtimeEnvironmentContext,
+      );
       runtimes[agentName] = new CodexRuntime(processManager, runtimeLogger);
       continue;
     }
-    const processManager = new AcpProcessManager(runtimeLogger);
+    const processManager = new AcpProcessManager(runtimeLogger, runtimeEnvironmentContext);
     const sessionManager = new AcpSessionManager(agentName, agent, processManager, runtimeLogger);
     runtimes[agentName] = new AcpRuntimeAdapter(sessionManager);
   }

package/src/runtime/types.ts

@@ -1,4 +1,8 @@
 export type RuntimeKind = "acp" | "codex";
+export interface AgentProcessInfo {
+  pid?: number;
+  version?: string;
+}
 export type PermissionMode = "auto" | "confirm";
 export type ApprovalDecision = "accept" | "acceptForSession" | "decline" | "cancel";
 export type ToolStatus = "running" | "completed" | "failed";
@@ -203,6 +207,7 @@ export interface ReasoningEffortOption {
 
 export interface AgentRuntime {
   readonly kind: RuntimeKind;
+  getProcessInfo?(): AgentProcessInfo;
   createSession(input: CreateRuntimeSessionInput): Promise<RuntimeSession>;
   resumeSession(input: ResumeRuntimeSessionInput): Promise<RuntimeSession>;
   forkSession?(input: ForkRuntimeSessionInput): Promise<RuntimeSession>;

package/src/startup/StartupNotifier.ts

@@ -1,6 +1,7 @@
 import type { Logger } from "pino";
 import { detectProjectlessWorkspace } from "../codex/ProjectlessWorkspace.js";
 import { CardRenderer } from "../feishu/CardRenderer.js";
+import { baseChatContextKey, isThreadContextKey } from "../feishu/contextKey.js";
 import type { FeishuOutbound } from "../feishu/types.js";
 import type { SessionRecord, StateStore, UserContextRecord } from "../state/StateStore.js";
 
@@ -32,15 +33,30 @@ export class StartupNotifier {
     private readonly metadataHydrator?: StartupTaskMetadataHydrator,
   ) {}
 
-  async notify(startedAt: Date, restartReason: string): Promise<void> {
+  async notify(
+    startedAt: Date,
+    restartReason: string,
+    restartGroupContextKeys: string[] = [],
+  ): Promise<void> {
     let targets: StartupNotificationTarget[];
     try {
-      const activeGroupSince = new Date(startedAt.getTime() - 3 * 60 * 1_000);
-      const chats = [
-        ...this.store.listChatContexts("p2p"),
-        ...this.store.listRecentlyActiveChatContexts(activeGroupSince)
-          .filter((chat) => chat.chatType === "group"),
-      ];
+      const activeGroupSince = new Date(startedAt.getTime() - 60_000);
+      const knownGroups = new Map(
+        this.store.listChatContexts("group")
+          .filter((chat) => !isThreadContextKey(chat.contextKey))
+          .map((chat) => [chat.contextKey, chat]),
+      );
+      const targetGroups = new Map(
+        this.store.listRecentlyActiveChatContexts(activeGroupSince)
+          .filter((chat) => chat.chatType === "group" && !isThreadContextKey(chat.contextKey))
+          .map((chat) => [chat.contextKey, chat]),
+      );
+      for (const contextKey of restartGroupContextKeys) {
+        const baseContextKey = baseChatContextKey(contextKey.trim());
+        const group = knownGroups.get(baseContextKey);
+        if (group) targetGroups.set(baseContextKey, group);
+      }
+      const chats = [...this.store.listChatContexts("p2p"), ...targetGroups.values()];
       targets = chats.map((chat) => ({
         contextKey: chat.contextKey,
         context: this.store.getUserContext(chat.contextKey),

package/src/startup/startFeishu.ts

@@ -3,7 +3,7 @@ export interface StartableFeishuConnector {
 }
 
 export interface StartupNotificationSender {
-  notify(startedAt: Date, restartReason: string): Promise<void>;
+  notify(startedAt: Date, restartReason: string, restartGroupContextKeys?: string[]): Promise<void>;
 }
 
 export async function startFeishu(
@@ -13,9 +13,10 @@ export async function startFeishu(
   restartReason: string,
   prepare?: () => Promise<void>,
   onConnected?: () => void,
+  restartGroupContextKeys: string[] = [],
 ): Promise<void> {
   await prepare?.();
   await connector.start();
-  await notifier.notify(startedAt, restartReason);
+  await notifier.notify(startedAt, restartReason, restartGroupContextKeys);
   onConnected?.();
 }

package/src/state/StateStore.ts

@@ -63,6 +63,21 @@ export interface TurnAnchorRecord {
   contextKey?: string;
 }
 
+export interface TurnRuntimeOriginRecord {
+  turnId: string;
+  localSessionId: string;
+  agentName: string;
+  remoteSessionId: string;
+  createdAt: string;
+}
+
+export interface CompletedTurnSnapshotRecord {
+  turnId: string;
+  parentTurnId?: string;
+  snapshot: unknown;
+  updatedAt: string;
+}
+
 export interface QueuedPromptRecord {
   promptId: string;
   localSessionId: string;
@@ -605,6 +620,54 @@ export class StateStore {
     return row ? JSON.parse(row.snapshot_json) : undefined;
   }
 
+  saveTurnRuntimeOrigin(
+    turnId: string,
+    localSessionId: string,
+    agentName: string,
+    remoteSessionId: string,
+  ): void {
+    this.db.prepare(`
+      INSERT OR IGNORE INTO turn_runtime_origins (
+        turn_id, local_session_id, agent_name, remote_session_id, created_at
+      ) VALUES (?, ?, ?, ?, ?)
+    `).run(turnId, localSessionId, agentName, remoteSessionId, new Date().toISOString());
+  }
+
+  getTurnRuntimeOrigin(turnId: string): TurnRuntimeOriginRecord | undefined {
+    const row = this.db.prepare(`
+      SELECT turn_id, local_session_id, agent_name, remote_session_id, created_at
+      FROM turn_runtime_origins
+      WHERE turn_id = ?
+    `).get(turnId) as {
+      turn_id: string;
+      local_session_id: string;
+      agent_name: string;
+      remote_session_id: string;
+      created_at: string;
+    } | undefined;
+    return row
+      ? {
+          turnId: row.turn_id,
+          localSessionId: row.local_session_id,
+          agentName: row.agent_name,
+          remoteSessionId: row.remote_session_id,
+          createdAt: row.created_at,
+        }
+      : undefined;
+  }
+
+  saveTurnParent(turnId: string, localSessionId: string, parentTurnId?: string): void {
+    this.db.prepare(`
+      INSERT INTO turn_parent_links (
+        turn_id, local_session_id, parent_turn_id, created_at
+      ) VALUES (?, ?, ?, ?)
+      ON CONFLICT(turn_id) DO UPDATE SET
+        parent_turn_id = excluded.parent_turn_id
+      WHERE turn_parent_links.parent_turn_id IS NULL
+        AND excluded.parent_turn_id IS NOT NULL
+    `).run(turnId, localSessionId, parentTurnId ?? null, new Date().toISOString());
+  }
+
   findLatestCompletedTurnId(localSessionId: string, contextKey: string): string | undefined {
     const row = this.db
       .prepare(`
@@ -626,6 +689,142 @@ export class StateStore {
     return row?.turn_id;
   }
 
+  countCompletedTurnSnapshots(localSessionId: string, contextKey: string): number {
+    const row = this.db.prepare(`
+      SELECT count(*) AS count
+      FROM turn_snapshots
+      WHERE local_session_id = ?
+        AND context_key = ?
+        AND json_extract(snapshot_json, '$.status') = 'completed'
+    `).get(localSessionId, contextKey) as { count: number };
+    return row.count;
+  }
+
+  listCompletedTurnSnapshots(
+    localSessionId: string,
+    contextKey: string,
+    limit: number,
+    offset = 0,
+  ): CompletedTurnSnapshotRecord[] {
+    const normalizedLimit = Math.max(1, Math.min(100, Math.trunc(limit)));
+    const normalizedOffset = Math.max(0, Math.trunc(offset));
+    const rows = this.db.prepare(`
+      SELECT turn_id, snapshot_json, updated_at
+      FROM turn_snapshots
+      WHERE local_session_id = ?
+        AND context_key = ?
+        AND json_extract(snapshot_json, '$.status') = 'completed'
+      ORDER BY
+        coalesce(
+          json_extract(snapshot_json, '$.completedAt'),
+          json_extract(snapshot_json, '$.startedAt'),
+          0
+        ) DESC,
+        updated_at DESC
+      LIMIT ? OFFSET ?
+    `).all(localSessionId, contextKey, normalizedLimit, normalizedOffset) as Array<{
+      turn_id: string;
+      snapshot_json: string;
+      updated_at: string;
+    }>;
+    return rows.map((row) => ({
+      turnId: row.turn_id,
+      snapshot: JSON.parse(row.snapshot_json),
+      updatedAt: row.updated_at,
+    }));
+  }
+
+  listCompletedTurnGraph(
+    localSessionId: string,
+    contextKey: string,
+  ): CompletedTurnSnapshotRecord[] {
+    this.backfillTurnParents(localSessionId);
+    const rows = this.db.prepare(`
+      SELECT ts.turn_id, tpl.parent_turn_id, ts.snapshot_json, ts.updated_at
+      FROM turn_snapshots ts
+      LEFT JOIN turn_parent_links tpl ON tpl.turn_id = ts.turn_id
+      WHERE ts.local_session_id = ?
+        AND ts.context_key = ?
+        AND json_extract(ts.snapshot_json, '$.status') = 'completed'
+      ORDER BY
+        coalesce(
+          json_extract(ts.snapshot_json, '$.completedAt'),
+          json_extract(ts.snapshot_json, '$.startedAt'),
+          0
+        ) DESC,
+        ts.updated_at DESC
+    `).all(localSessionId, contextKey) as Array<{
+      turn_id: string;
+      parent_turn_id: string | null;
+      snapshot_json: string;
+      updated_at: string;
+    }>;
+    return rows.map((row) => ({
+      turnId: row.turn_id,
+      parentTurnId: row.parent_turn_id ?? undefined,
+      snapshot: JSON.parse(row.snapshot_json),
+      updatedAt: row.updated_at,
+    }));
+  }
+
+  private backfillTurnParents(localSessionId: string): void {
+    const turns = this.db.prepare(`
+      SELECT
+        turn_id,
+        coalesce(
+          json_extract(snapshot_json, '$.startedAt'),
+          json_extract(snapshot_json, '$.completedAt'),
+          cast(strftime('%s', updated_at) AS INTEGER) * 1000,
+          0
+        ) AS started_at
+      FROM turn_snapshots
+      WHERE local_session_id = ?
+        AND json_extract(snapshot_json, '$.status') = 'completed'
+      ORDER BY started_at ASC, updated_at ASC
+    `).all(localSessionId) as Array<{ turn_id: string; started_at: number }>;
+    if (turns.length === 0) return;
+
+    const resets = (this.db.prepare(`
+      SELECT payload_json, created_at
+      FROM audit_events
+      WHERE event_type = 'session_reset_to_turn'
+        AND json_extract(payload_json, '$.localSessionId') = ?
+      ORDER BY created_at ASC, id ASC
+    `).all(localSessionId) as Array<{ payload_json: string; created_at: string }>).flatMap((row) => {
+      try {
+        const payload = JSON.parse(row.payload_json) as { resetTurnId?: unknown };
+        const resetTurnId = typeof payload.resetTurnId === "string" ? payload.resetTurnId : undefined;
+        const at = Date.parse(row.created_at);
+        return resetTurnId && Number.isFinite(at) ? [{ resetTurnId, at }] : [];
+      } catch {
+        return [];
+      }
+    });
+
+    let headTurnId: string | undefined;
+    let resetIndex = 0;
+    const upsert = this.db.prepare(`
+      INSERT INTO turn_parent_links (
+        turn_id, local_session_id, parent_turn_id, created_at
+      ) VALUES (?, ?, ?, ?)
+      ON CONFLICT(turn_id) DO UPDATE SET
+        parent_turn_id = excluded.parent_turn_id
+      WHERE turn_parent_links.parent_turn_id IS NULL
+        AND excluded.parent_turn_id IS NOT NULL
+    `);
+    const backfill = this.db.transaction(() => {
+      for (const turn of turns) {
+        while (resetIndex < resets.length && resets[resetIndex]!.at <= turn.started_at) {
+          headTurnId = resets[resetIndex]!.resetTurnId;
+          resetIndex += 1;
+        }
+        upsert.run(turn.turn_id, localSessionId, headTurnId ?? null, new Date().toISOString());
+        headTurnId = turn.turn_id;
+      }
+    });
+    backfill();
+  }
+
   saveTurnDelivery(
     turnId: string,
     patch: { progressMessageId?: string; lastCardHash?: string },
@@ -784,6 +983,31 @@ export class StateStore {
     return rows.map(mapSession);
   }
 
+  findLatestMessageIdForSession(localSessionId: string, contextKey?: string): string | undefined {
+    const row = this.db.prepare(`
+      SELECT message_id
+      FROM message_reactions
+      WHERE local_session_id = ?
+        AND (? IS NULL OR context_key = ?)
+      ORDER BY created_at DESC, rowid DESC
+      LIMIT 1
+    `).get(localSessionId, contextKey ?? null, contextKey ?? null) as { message_id: string } | undefined;
+    return row?.message_id;
+  }
+
+  findLatestMessageIdForContext(contextKey: string): string | undefined {
+    const row = this.db.prepare(`
+      SELECT json_extract(payload_json, '$.messageId') AS message_id
+      FROM audit_events
+      WHERE context_key = ?
+        AND event_type = 'incoming_message'
+        AND json_type(payload_json, '$.messageId') = 'text'
+      ORDER BY id DESC
+      LIMIT 1
+    `).get(contextKey) as { message_id: string } | undefined;
+    return row?.message_id;
+  }
+
   getServerActivityState(): {
     runningSessions: number;
     pendingFinalDeliveries: number;

package/src/state/migrations.ts

@@ -125,4 +125,25 @@ export const migrations = [
   CREATE INDEX IF NOT EXISTS idx_queued_prompts_session_order
     ON queued_prompts(local_session_id, created_at);
   `,
+  `
+  CREATE TABLE IF NOT EXISTS turn_runtime_origins (
+    turn_id TEXT PRIMARY KEY,
+    local_session_id TEXT NOT NULL,
+    agent_name TEXT NOT NULL,
+    remote_session_id TEXT NOT NULL,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_turn_runtime_origins_session
+    ON turn_runtime_origins(local_session_id);
+  `,
+  `
+  CREATE TABLE IF NOT EXISTS turn_parent_links (
+    turn_id TEXT PRIMARY KEY,
+    local_session_id TEXT NOT NULL,
+    parent_turn_id TEXT,
+    created_at TEXT NOT NULL
+  );
+  CREATE INDEX IF NOT EXISTS idx_turn_parent_links_session
+    ON turn_parent_links(local_session_id);
+  `,
 ] as const;

package/src/supervision/SafeRestartNotifier.ts

@@ -1,8 +1,9 @@
 import type { Logger } from "pino";
 import { CardRenderer } from "../feishu/CardRenderer.js";
+import { isThreadContextKey } from "../feishu/contextKey.js";
 import type { FeishuOutbound } from "../feishu/types.js";
 import type { StateStore } from "../state/StateStore.js";
-import type { SafeRestartStatus } from "./SafeRestartScheduler.js";
+import type { RestartNotificationTarget, SafeRestartStatus } from "./SafeRestartScheduler.js";
 
 const DEFAULT_INITIAL_CARD_DELAY_MS = 3_000;
 
@@ -13,6 +14,7 @@ export interface SafeRestartNotifierOptions {
 export class SafeRestartNotifier {
   private readonly messageIds = new Map<string, string>();
   private readonly cardHashes = new Map<string, string>();
+  private readonly notificationTargets = new Map<string, RestartNotificationTarget>();
   private activeScheduleId?: number;
   private terminalScheduleId?: number;
   private pendingInitialStatus?: SafeRestartStatus;
@@ -41,8 +43,10 @@ export class SafeRestartNotifier {
       this.activeScheduleId = status.scheduleId;
       this.messageIds.clear();
       this.cardHashes.clear();
+      this.notificationTargets.clear();
       this.clearInitialCardTimer();
       this.pendingInitialStatus = status;
+      this.collectNotificationTargets(status);
       const delayMs = status.phase === "cancelled"
         ? 0
         : this.options.initialCardDelayMs ?? DEFAULT_INITIAL_CARD_DELAY_MS;
@@ -55,6 +59,7 @@ export class SafeRestartNotifier {
       }, delayMs);
       return Promise.resolve();
     }
+    this.collectNotificationTargets(status);
     if (this.pendingInitialStatus) {
       this.pendingInitialStatus = status;
       return Promise.resolve();
@@ -67,6 +72,10 @@ export class SafeRestartNotifier {
     await this.queue;
   }
 
+  getNotificationTargets(): RestartNotificationTarget[] {
+    return [...this.notificationTargets.values()].map((target) => ({ ...target }));
+  }
+
   private publishPendingInitialStatus(): Promise<void> {
     this.clearInitialCardTimer();
     const status = this.pendingInitialStatus;
@@ -89,7 +98,8 @@ export class SafeRestartNotifier {
   }
 
   private async publish(status: SafeRestartStatus): Promise<void> {
-    const targets = this.store.listChatContexts("p2p");
+    this.collectNotificationTargets(status);
+    const targets = this.getNotificationTargets();
     if (targets.length === 0) return;
     const waitingTasks = status.phase === "cancelled"
       ? []
@@ -109,7 +119,7 @@ export class SafeRestartNotifier {
     });
     const cardHash = JSON.stringify(card);
 
-    await Promise.all(targets.map(async ({ contextKey }) => {
+    await Promise.all(targets.map(async ({ contextKey, replyMessageId }) => {
       const messageId = this.messageIds.get(contextKey);
       if (messageId) {
         if (this.cardHashes.get(contextKey) === cardHash) return;
@@ -124,7 +134,22 @@ export class SafeRestartNotifier {
         }
       }
       try {
-        const created = await this.outbound.sendInteractiveCard(contextKey, card);
+        let created: string | undefined;
+        if (isThreadContextKey(contextKey) && !replyMessageId) {
+          throw new Error("The safe-restart topic target has no reply message anchor.");
+        }
+        if (replyMessageId) {
+          if (!this.outbound.replyInteractiveCard) {
+            throw new Error("The outbound transport cannot preserve the requesting thread.");
+          }
+          created = await this.outbound.replyInteractiveCard(
+            contextKey,
+            { messageId: replyMessageId, replyInThread: true },
+            card,
+          );
+        } else {
+          created = await this.outbound.sendInteractiveCard(contextKey, card);
+        }
         if (created && this.activeScheduleId === status.scheduleId) {
           this.messageIds.set(contextKey, created);
           this.cardHashes.set(contextKey, cardHash);
@@ -134,4 +159,28 @@ export class SafeRestartNotifier {
       }
     }));
   }
+
+  private collectNotificationTargets(status: SafeRestartStatus): void {
+    const requestedTargets: RestartNotificationTarget[] = status.notificationTargets
+      ?? this.store.listChatContexts("p2p").map(({ contextKey }) => ({ contextKey }));
+    const recentTargets: RestartNotificationTarget[] = this.store.listRecentlyActiveChatContexts(
+      new Date(Date.now() - 60_000),
+    )
+      .filter((chat) => !isThreadContextKey(chat.contextKey))
+      .map(({ contextKey }) => ({ contextKey }));
+    for (const target of [
+      ...requestedTargets,
+      ...recentTargets,
+    ]) {
+      const contextKey = target.contextKey.trim();
+      if (!contextKey) continue;
+      const existing = this.notificationTargets.get(contextKey);
+      if (!existing || (!existing.replyMessageId && target.replyMessageId)) {
+        this.notificationTargets.set(contextKey, {
+          contextKey,
+          ...(target.replyMessageId?.trim() ? { replyMessageId: target.replyMessageId.trim() } : {}),
+        });
+      }
+    }
+  }
 }