switchroom 0.18.32 → 0.19.0

package/telegram-plugin/tests/bot-commands-model-effort.test.ts

@@ -0,0 +1,189 @@
+/**
+ * Outcome pins for the /model and /effort commands extracted from gateway.ts
+ * (switchroom#2996 P6 bot.command drain). Registers against a fake grammy Bot
+ * and drives the captured handlers with mock contexts: asserts the durable
+ * receipt-first contract (#3177 — log line + history row before any branch),
+ * the busy → ack+queue disposition (#3017/#3262), the menu path, and the
+ * direct-apply path for both commands.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import {
+  registerModelEffortCommands,
+  type ModelEffortCommandDeps,
+} from '../gateway/bot-commands-model-effort.js'
+
+type Handler = (ctx: any) => Promise<void>
+
+function fakeBot() {
+  const handlers = new Map<string, Handler>()
+  return {
+    bot: { command: (name: string, h: Handler) => void handlers.set(name, h) } as any,
+    handlers,
+  }
+}
+
+function makeDeps(over: Partial<ModelEffortCommandDeps> = {}) {
+  const log = vi.fn()
+  const recordInbound = vi.fn()
+  const enqueueSessionCommand = vi.fn()
+  const switchroomReply = vi.fn(async () => {})
+  const deps: ModelEffortCommandDeps = {
+    isAuthorizedSender: () => true,
+    getMyAgentName: () => 'klanker',
+    resolveThreadId: () => undefined,
+    resolveModelEffortBusy: () => ({ currentTurnActive: false, turnInFlight: false }),
+    historyEnabled: true,
+    recordInbound,
+    buildModelDeps: () => ({
+      discover: async () => ({ models: [], current: null }),
+      isBusy: () => false,
+      getAgentName: () => 'klanker',
+      getQuotaBrief: async () => null,
+      discoverSrModels: async () => [],
+      escapeHtml: (s: string) => s,
+      getConfiguredModel: () => 'opus',
+      preBlock: (s: string) => s,
+      scheduleRestart: async () => {},
+      scheduleModelRelaunch: async () => {},
+      scheduleModelDefaultRelaunch: async () => {},
+    }) as any,
+    buildEffortDeps: () => ({
+      applyEffort: vi.fn(async () => ({ ok: true })),
+      getAgentName: () => 'klanker',
+      getConfiguredEffort: () => 'high',
+      getSessionEffort: () => null,
+      escapeHtml: (s: string) => s,
+    }) as any,
+    modelMenuReplyMarkup: () => undefined,
+    effortMenuReplyMarkup: () => undefined,
+    enqueueSessionCommand,
+    switchroomReply,
+    modelMenuEnabled: () => true,
+    log,
+    ...over,
+  }
+  return { deps, log, recordInbound, enqueueSessionCommand, switchroomReply }
+}
+
+function makeCtx(text: string) {
+  return {
+    message: { text, message_id: 7, date: 1000 },
+    chat: { id: 42 },
+    from: { id: 11, username: 'ken' },
+    replyWithRichMessage: vi.fn(async () => ({ message_id: 900 })),
+  }
+}
+
+describe('/model', () => {
+  it('drops unauthorized senders silently', async () => {
+    const { bot, handlers } = fakeBot()
+    const { deps, log } = makeDeps({ isAuthorizedSender: () => false })
+    registerModelEffortCommands(bot, deps)
+    await handlers.get('model')!(makeCtx('/model'))
+    expect(log).not.toHaveBeenCalled()
+  })
+
+  it('writes the durable receipt (log + history row) BEFORE any branch (#3177)', async () => {
+    const { bot, handlers } = fakeBot()
+    const { deps, log, recordInbound } = makeDeps()
+    registerModelEffortCommands(bot, deps)
+    await handlers.get('model')!(makeCtx('/model'))
+    expect(log.mock.calls[0][0]).toContain('model')
+    expect(recordInbound).toHaveBeenCalledWith(
+      expect.objectContaining({ chat_id: '42', message_id: 7, user: 'ken', text: '/model' }),
+    )
+  })
+
+  it('bare /model on an idle session opens the menu via switchroomReply', async () => {
+    const { bot, handlers } = fakeBot()
+    const buildModelDeps = vi.fn(() => ({
+      // ModelMenuDeps shape — what buildModelMenu really reads.
+      discover: async () => ({ models: [], current: null }),
+      isBusy: () => false,
+      getAgentName: () => 'klanker',
+      getQuotaBrief: async () => null,
+      discoverSrModels: async () => [],
+      escapeHtml: (s: string) => s,
+      getConfiguredModel: () => 'opus',
+      preBlock: (s: string) => s,
+      scheduleRestart: async () => {},
+      scheduleModelRelaunch: async () => {},
+      scheduleModelDefaultRelaunch: async () => {},
+    }) as any)
+    const { deps, switchroomReply } = makeDeps({ buildModelDeps })
+    registerModelEffortCommands(bot, deps)
+    await handlers.get('model')!(makeCtx('/model'))
+    expect(switchroomReply).toHaveBeenCalledTimes(1)
+    expect(switchroomReply.mock.calls[0][2]).toMatchObject({ html: true })
+  })
+
+  it('typed /model <target> while BUSY acks and queues instead of applying (#3017)', async () => {
+    const { bot, handlers } = fakeBot()
+    const { deps, enqueueSessionCommand, switchroomReply } = makeDeps({
+      resolveModelEffortBusy: () => ({ currentTurnActive: true, turnInFlight: true }),
+    })
+    registerModelEffortCommands(bot, deps)
+    const ctx = makeCtx('/model opus')
+    await handlers.get('model')!(ctx)
+    expect(ctx.replyWithRichMessage).toHaveBeenCalledTimes(1)
+    expect(enqueueSessionCommand).toHaveBeenCalledWith(
+      expect.objectContaining({
+        kind: 'model',
+        origin: 'typed',
+        arg: 'opus',
+        ackChatId: '42',
+        ackMessageId: 900,
+      }),
+    )
+    expect(switchroomReply).not.toHaveBeenCalled()
+  })
+})
+
+describe('/effort', () => {
+  it('shows the menu for bare /effort', async () => {
+    const { bot, handlers } = fakeBot()
+    const buildEffortDeps = vi.fn(() => ({
+      applyEffort: vi.fn(async () => ({ ok: true })),
+      getAgentName: () => 'klanker',
+      getConfiguredEffort: () => 'high',
+      getSessionEffort: () => null,
+      escapeHtml: (s: string) => s,
+    }) as any)
+    const { deps, switchroomReply } = makeDeps({ buildEffortDeps })
+    registerModelEffortCommands(bot, deps)
+    await handlers.get('effort')!(makeCtx('/effort'))
+    expect(switchroomReply).toHaveBeenCalledTimes(1)
+    expect(switchroomReply.mock.calls[0][2]).toMatchObject({ html: true })
+  })
+
+  it('set while busy: acks and queues with the requested level', async () => {
+    const { bot, handlers } = fakeBot()
+    const { deps, enqueueSessionCommand } = makeDeps({
+      resolveModelEffortBusy: () => ({ currentTurnActive: true, turnInFlight: false }),
+    })
+    registerModelEffortCommands(bot, deps)
+    const ctx = makeCtx('/effort low')
+    await handlers.get('effort')!(ctx)
+    expect(ctx.replyWithRichMessage).toHaveBeenCalledTimes(1)
+    expect(enqueueSessionCommand).toHaveBeenCalledWith(
+      expect.objectContaining({ kind: 'effort', arg: 'low', targetLabel: 'low' }),
+    )
+  })
+
+  it('set while idle: applies via handleEffortCommand and replies', async () => {
+    const { bot, handlers } = fakeBot()
+    const buildEffortDeps = vi.fn(() => ({
+      applyEffort: vi.fn(async () => ({ ok: true })),
+      getAgentName: () => 'klanker',
+      getConfiguredEffort: () => 'high',
+      getSessionEffort: () => null,
+      escapeHtml: (s: string) => s,
+    }) as any)
+    const { deps, switchroomReply, enqueueSessionCommand } = makeDeps({ buildEffortDeps })
+    registerModelEffortCommands(bot, deps)
+    await handlers.get('effort')!(makeCtx('/effort low'))
+    expect(enqueueSessionCommand).not.toHaveBeenCalled()
+    expect(switchroomReply).toHaveBeenCalledTimes(1)
+  })
+})

package/telegram-plugin/tests/bot-commands-start-info.test.ts

@@ -0,0 +1,240 @@
+/**
+ * Outcome pins for the /start /help /status /agents commands extracted from
+ * gateway.ts (switchroom#2996 P6 bot.command drain). Registers against a fake
+ * grammy Bot, captures the handlers, and drives them with mock contexts:
+ * asserts the dmCommandGate silent-drop, the disabled-flag plumbing into the
+ * start text, the paired/pending/unpaired /status branches, and the /agents
+ * formatter output fed through runSwitchroomCommandFormatted.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import {
+  registerStartInfoCommands,
+  type StartInfoCommandDeps,
+} from '../gateway/bot-commands-start-info.js'
+
+type Handler = (ctx: any) => Promise<void>
+
+function fakeBot() {
+  const handlers = new Map<string, Handler>()
+  return {
+    bot: { command: (name: string, h: Handler) => void handlers.set(name, h) } as any,
+    handlers,
+  }
+}
+
+function makeDeps(over: Partial<StartInfoCommandDeps> = {}): StartInfoCommandDeps {
+  return {
+    dmCommandGate: () => ({
+      access: { dmPolicy: 'allowlist', allowFrom: ['42'], pending: {} } as any,
+      senderId: '42',
+    }),
+    isAuthorizedSender: () => true,
+    getMyAgentName: () => 'klanker',
+    getCommandArgs: () => '',
+    hasDemoFlag: () => false,
+    buildAgentMetadata: async () =>
+      ({
+        agentName: 'klanker',
+        model: 'opus',
+        extendsProfile: null,
+        topicName: null,
+        topicEmoji: null,
+        uptime: '2h',
+        status: 'running',
+        auth: null,
+      }) as any,
+    runSwitchroomCommandFormatted: vi.fn(async (_ctx, _args, _label, formatter) => {
+      formatter()
+    }),
+    switchroomExecJson: () => null,
+    statusIcon: () => '🟢',
+    ...over,
+  }
+}
+
+function makeCtx(over: Record<string, unknown> = {}) {
+  return {
+    from: { username: 'ken' },
+    reply: vi.fn(async () => {}),
+    replyWithRichMessage: vi.fn(async () => {}),
+    ...over,
+  }
+}
+
+describe('/start and /help', () => {
+  it('silently drops when dmCommandGate rejects', async () => {
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(bot, makeDeps({ dmCommandGate: () => null }))
+    const ctx = makeCtx()
+    await handlers.get('start')!(ctx)
+    await handlers.get('help')!(ctx)
+    expect(ctx.replyWithRichMessage).not.toHaveBeenCalled()
+    expect(ctx.reply).not.toHaveBeenCalled()
+  })
+
+  it('replies with the start text, carrying the disabled flag through', async () => {
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(
+      bot,
+      makeDeps({
+        dmCommandGate: () => ({
+          access: { dmPolicy: 'disabled', allowFrom: [], pending: {} } as any,
+          senderId: '42',
+        }),
+      }),
+    )
+    const ctx = makeCtx()
+    await handlers.get('start')!(ctx)
+    expect(ctx.replyWithRichMessage).toHaveBeenCalledTimes(1)
+    // welcome-text startText(name, disabled=true) renders the disabled notice.
+    const arg = ctx.replyWithRichMessage.mock.calls[0][0]
+    expect(JSON.stringify(arg)).toContain("isn't accepting new connections")
+  })
+
+  it('replies with the help text for allowed senders', async () => {
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(bot, makeDeps())
+    const ctx = makeCtx()
+    await handlers.get('help')!(ctx)
+    expect(ctx.replyWithRichMessage).toHaveBeenCalledTimes(1)
+  })
+})
+
+describe('/status branches', () => {
+  it('paired: builds agent metadata and replies rich', async () => {
+    const buildAgentMetadata = vi.fn(async () =>
+      ({
+        agentName: 'klanker',
+        model: 'opus',
+        extendsProfile: null,
+        topicName: null,
+        topicEmoji: null,
+        uptime: '2h',
+        status: 'running',
+        auth: null,
+      }) as any)
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(bot, makeDeps({ buildAgentMetadata }))
+    const ctx = makeCtx()
+    await handlers.get('status')!(ctx)
+    expect(buildAgentMetadata).toHaveBeenCalledWith('klanker')
+    expect(ctx.replyWithRichMessage).toHaveBeenCalledTimes(1)
+    expect(ctx.reply).not.toHaveBeenCalled()
+  })
+
+  it('pending: replies with the pairing-code text', async () => {
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(
+      bot,
+      makeDeps({
+        dmCommandGate: () => ({
+          access: {
+            dmPolicy: 'pairing',
+            allowFrom: [],
+            pending: { ABC123: { senderId: '42' } },
+          } as any,
+          senderId: '42',
+        }),
+      }),
+    )
+    const ctx = makeCtx()
+    await handlers.get('status')!(ctx)
+    expect(ctx.replyWithRichMessage).toHaveBeenCalledTimes(1)
+    expect(JSON.stringify(ctx.replyWithRichMessage.mock.calls[0][0])).toContain('ABC123')
+  })
+
+  it('unpaired: falls through to the plain unpaired reply', async () => {
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(
+      bot,
+      makeDeps({
+        dmCommandGate: () => ({
+          access: { dmPolicy: 'pairing', allowFrom: [], pending: {} } as any,
+          senderId: '42',
+        }),
+      }),
+    )
+    const ctx = makeCtx()
+    await handlers.get('status')!(ctx)
+    expect(ctx.reply).toHaveBeenCalledTimes(1)
+    expect(ctx.replyWithRichMessage).not.toHaveBeenCalled()
+  })
+})
+
+describe('/agents', () => {
+  it('drops unauthorized senders before running the CLI', async () => {
+    const runSwitchroomCommandFormatted = vi.fn(async () => {})
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(
+      bot,
+      makeDeps({ isAuthorizedSender: () => false, runSwitchroomCommandFormatted }),
+    )
+    await handlers.get('agents')!(makeCtx())
+    expect(runSwitchroomCommandFormatted).not.toHaveBeenCalled()
+  })
+
+  it('formats the agent list exactly (icon, name, status, uptime, template line)', async () => {
+    let formatted: string | null = ''
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(
+      bot,
+      makeDeps({
+        runSwitchroomCommandFormatted: vi.fn(async (_c, args, label, formatter) => {
+          expect(args).toEqual(['agent', 'list'])
+          expect(label).toBe('agent list')
+          formatted = formatter()
+        }),
+        switchroomExecJson: <T,>() =>
+          ({
+            agents: [
+              {
+                name: 'klanker',
+                status: 'running',
+                uptime: '2h',
+                template: 'root-debug',
+                topic_name: 'DM',
+                topic_emoji: '🔧',
+              },
+            ],
+          }) as T,
+      }),
+    )
+    await handlers.get('agents')!(makeCtx())
+    expect(formatted).toBe(
+      '**Agents**\n🟢 **klanker** · running · 2h\n    _root-debug → DM 🔧_',
+    )
+  })
+
+  it('renders the empty-list placeholder', async () => {
+    let formatted: string | null = ''
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(
+      bot,
+      makeDeps({
+        runSwitchroomCommandFormatted: vi.fn(async (_c, _a, _l, formatter) => {
+          formatted = formatter()
+        }),
+        switchroomExecJson: <T,>() => ({ agents: [] }) as T,
+      }),
+    )
+    await handlers.get('agents')!(makeCtx())
+    expect(formatted).toBe('_No agents defined_')
+  })
+
+  it('returns null (CLI failure passthrough) when exec returns null', async () => {
+    let formatted: string | null = 'sentinel'
+    const { bot, handlers } = fakeBot()
+    registerStartInfoCommands(
+      bot,
+      makeDeps({
+        runSwitchroomCommandFormatted: vi.fn(async (_c, _a, _l, formatter) => {
+          formatted = formatter()
+        }),
+        switchroomExecJson: () => null,
+      }),
+    )
+    await handlers.get('agents')!(makeCtx())
+    expect(formatted).toBeNull()
+  })
+})

package/telegram-plugin/tests/buffer-gate-broadened.test.ts

@@ -37,12 +37,17 @@ const gatewaySrc = readFileSync(
   'utf-8',
 )
 // #2996 P2: executeReply's body moved verbatim to outbound-send-path.ts
-// (`sendReply`); the post-send block assertions read there. The
-// `releaseTurnBufferGate` helper itself stays in gateway.ts.
+// (`sendReply`); the post-send block assertions read there. #2996 P8 PR-B: the
+// `releaseTurnBufferGate` helper body moved verbatim to turn-end.ts (gateway
+// keeps a thin delegating wrapper); the helper-body assertions read there.
 const sendPathSrc = readFileSync(
   resolve(__dirname, '..', 'gateway', 'outbound-send-path.ts'),
   'utf-8',
 )
+const turnEndSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'turn-end.ts'),
+  'utf-8',
+)
 
 describe('buffer-gate release decoupled from final-answer classification', () => {
   // Extract the helper's docstring (everything between the matching
@@ -50,7 +55,7 @@ describe('buffer-gate release decoupled from final-answer classification', () =>
   // function declaration). The body slice (used by other tests) is
   // separate — see fnBody().
   function fnDocstring(): string {
-    const beforeFn = gatewaySrc.split('function releaseTurnBufferGate')[0] ?? ''
+    const beforeFn = turnEndSrc.split('function releaseTurnBufferGate')[0] ?? ''
     const lastBlockOpen = beforeFn.lastIndexOf('/**')
     if (lastBlockOpen < 0) return ''
     return beforeFn.slice(lastBlockOpen)
@@ -59,7 +64,7 @@ describe('buffer-gate release decoupled from final-answer classification', () =>
     // The function body — everything between `function
     // releaseTurnBufferGate(...): void {` and its matching `}`. Use
     // a simple brace-balance over the slice from open-brace onward.
-    const afterDecl = gatewaySrc.split('function releaseTurnBufferGate')[1] ?? ''
+    const afterDecl = turnEndSrc.split('function releaseTurnBufferGate')[1] ?? ''
     const openIdx = afterDecl.indexOf('{')
     if (openIdx < 0) return ''
     let depth = 0
@@ -78,7 +83,7 @@ describe('buffer-gate release decoupled from final-answer classification', () =>
     // Multitopic component 1: the signature now also accepts an optional
     // `endingTurn` so the serialize-until-replied drain gate can read its
     // finalAnswerDelivered flag. The narrow-helper contract is unchanged.
-    expect(gatewaySrc).toMatch(
+    expect(turnEndSrc).toMatch(
       /function releaseTurnBufferGate\(key: string, endingTurn\?: CurrentTurn\): void/,
     )
     // The helper docstring must explain WHY split from
@@ -152,6 +157,10 @@ describe('buffer-gate release decoupled from final-answer classification', () =>
     //     with executeStreamReply.)
     // If this count grows the test catches it; reviewer must justify
     // any new callsite.
-    expect(callMatches.length).toBe(4)
+    // #2996 P8 PR-B adds exactly one more match in gateway.ts: the thin
+    // wrapper's delegate call (`turnEndFunnel().releaseTurnBufferGate(...)`)
+    // alongside the wrapper's own declaration. Still only TWO turn-terminal
+    // callsites (sendReply post-send + executeHaltNow).
+    expect(callMatches.length).toBe(5)
   })
 })

package/telegram-plugin/tests/busy-ack-wiring.test.ts

@@ -20,6 +20,11 @@ const gatewaySrc = readFileSync(
   resolve(__dirname, '..', 'gateway', 'gateway.ts'),
   'utf-8',
 )
+// #2996 P8 PR-B: purgeReactionTracking's body moved verbatim to turn-end.ts.
+const turnEndSrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'turn-end.ts'),
+  'utf-8',
+)
 
 describe('#2995 mid-flight busy ack — gateway wiring', () => {
   it('the buffer-until-idle branch calls maybePostBusyAck for the inbound own chat/topic', () => {
@@ -97,7 +102,7 @@ describe('#2995 mid-flight busy ack — gateway wiring', () => {
   })
 
   it('turn-end cleanup is PER-KEY: dedupe entry deleted and re-check timer cancelled for the ending turn only', () => {
-    const purge = gatewaySrc.split('function purgeReactionTracking')[1]?.split('\nfunction ')[0] ?? ''
+    const purge = turnEndSrc.split('function purgeReactionTracking')[1]?.split('\nfunction ')[0] ?? ''
     // Per-key delete — a purge for topic A must not reset topic B's dedupe.
     expect(purge).toMatch(/busyAckPostedKeys\.delete\(key\)/)
     expect(purge).not.toMatch(/busyAckPostedKeys\.clear\(\)/)

package/telegram-plugin/tests/button-tap-turn-gated.test.ts

@@ -129,30 +129,39 @@ describe("agent button taps use the turn-gate (mid-turn → buffer)", () => {
   });
 
   describe("the agent: callback handler routes through the helper", () => {
+    // #2996 P6: the agent-callback family moved to
+    // agent-button-callback-handler.ts (handleAgentButtonCallback); the
+    // structural pins now scrape the extracted module. The injected
+    // deliverButtonTapInbound + restarting-notice bindings stay in gateway.ts.
+    const moduleSrc = readFileSync(
+      resolve(__dirname, "..", "gateway", "agent-button-callback-handler.ts"),
+      "utf8",
+    );
     it("delivers the tap via deliverButtonTapInbound, not a raw sendToAgent", () => {
-      // Locate the agent-callback handler block.
-      const anchor = gatewaySrc.indexOf("const agentCb = parseAgentCallback(data)");
+      const anchor = moduleSrc.indexOf("const agentCb = parseAgentCallback(data)");
       expect(anchor, "agent-callback handler missing").toBeGreaterThan(0);
-      const handler = gatewaySrc.slice(anchor, gatewaySrc.indexOf("// Permission request buttons.", anchor));
+      const handler = moduleSrc.slice(anchor);
       // The tap is routed through the turn-safe helper...
-      expect(handler).toMatch(/await deliverButtonTapInbound\(selfAgentBtn, inboundMsg\)/);
+      expect(handler).toMatch(/await deps\.deliverButtonTapInbound\(selfAgentBtn, inboundMsg\)/);
       // ...and NOT via a raw ungated sendToAgent of the tap inbound (the
       // regressed path that stranded the tap mid-turn).
       expect(handler).not.toMatch(/ipcServer\.sendToAgent\(selfAgentBtn, inboundMsg\)/);
+      // The gateway binding still wires the real helper.
+      expect(gatewaySrc).toMatch(/deliverButtonTapInbound,/);
     });
 
     it("still shows the restart notice only on bridge-offline", () => {
-      const anchor = gatewaySrc.indexOf("const agentCb = parseAgentCallback(data)");
-      const handler = gatewaySrc.slice(anchor, gatewaySrc.indexOf("// Permission request buttons.", anchor));
+      const handler = moduleSrc;
       // The restart notice is gated on the bridge-offline outcome — a mid-turn
       // buffered tap must NOT nag the user (it will be actioned at idle).
       expect(handler).toMatch(/btnOutcome === 'buffered-bridge-offline'/);
-      expect(handler).toMatch(/button-tap-restarting-notice/);
+      // The notice text + verb live in the gateway's injected binding.
+      expect(gatewaySrc).toMatch(/button-tap-restarting-notice/);
     });
 
     it("preserves the ack toast and single-use keyboard strip (UX unchanged)", () => {
-      const anchor = gatewaySrc.indexOf("const agentCb = parseAgentCallback(data)");
-      const handler = gatewaySrc.slice(anchor, gatewaySrc.indexOf("// Permission request buttons.", anchor));
+      const anchor = moduleSrc.indexOf("const agentCb = parseAgentCallback(data)");
+      const handler = moduleSrc.slice(anchor);
       // Ack toast fires FIRST (before delivery) so the tap always registers…
       const ackIdx = handler.indexOf("answerCallbackQuery({ text: ackText })");
       const deliverIdx = handler.indexOf("deliverButtonTapInbound(");