@otto-assistant/bridge 0.4.92

package/src/queue-advanced-question.e2e.test.ts

@@ -0,0 +1,316 @@
+// E2e test for question tool: user text message during pending question should
+// dismiss the question (abort), then enqueue as a normal user prompt.
+// The user's message must appear as a real user message in the thread, not
+// get consumed as a tool result answer (which lost voice/image content).
+
+import { describe, test, expect, afterEach } from 'vitest'
+import { setupQueueAdvancedSuite, TEST_USER_ID } from './queue-advanced-e2e-setup.js'
+import { waitForBotMessageContaining, waitForFooterMessage } from './test-utils.js'
+import { store, type DeterministicTranscriptionConfig } from './store.js'
+import { getOpencodeClient } from './opencode.js'
+import { getThreadSession } from './database.js'
+import type { Message, Part } from '@opencode-ai/sdk/v2'
+
+const TEXT_CHANNEL_ID = '200000000000001007'
+const VOICE_CHANNEL_ID = '200000000000001017'
+
+function setDeterministicTranscription(config: DeterministicTranscriptionConfig | null) {
+  store.setState({
+    test: { deterministicTranscription: config },
+  })
+}
+
+type SessionMessage = { info: Message; parts: Part[] }
+
+function getOpencodeClientForTest(projectDirectory: string) {
+  const client = getOpencodeClient(projectDirectory)
+  if (!client) {
+    throw new Error('OpenCode client not found for project directory')
+  }
+  return client
+}
+
+function getTextFromParts(parts: Part[]): string[] {
+  return parts.flatMap((part) => {
+    if (part.type === 'text') {
+      return [part.text]
+    }
+    return []
+  })
+}
+
+function normalizeSessionText(text: string): string {
+  return text
+    .replace(/\[current git branch is [^\]]+\]/g, '')
+    .replace(/<discord-user[^>]*\/>/g, '<discord-user />')
+    .trim()
+}
+
+function getSessionRoleTextTimeline(messages: SessionMessage[]) {
+  return messages.flatMap((message) => {
+    const text = normalizeSessionText(getTextFromParts(message.parts).join(''))
+    if (!text.trim()) {
+      return []
+    }
+    return [{ role: message.info.role, text }]
+  })
+}
+
+function getSessionMessageSummary(messages: SessionMessage[]) {
+  return messages.map((message) => {
+    return {
+      role: message.info.role,
+      parts: message.parts.map((part) => {
+        if (part.type === 'text') {
+          return {
+            type: part.type,
+            text: normalizeSessionText(part.text),
+          }
+        }
+        if (part.type === 'tool') {
+          return {
+            type: part.type,
+            tool: part.tool,
+            status: part.state.status,
+            title: part.state.status === 'completed' ? part.state.title : undefined,
+            output: part.state.status === 'completed' ? part.state.output : undefined,
+          }
+        }
+        return { type: part.type }
+      }),
+    }
+  })
+}
+
+async function waitForSessionMessages({
+  projectDirectory,
+  sessionId,
+  timeoutMs,
+  predicate,
+}: {
+  projectDirectory: string
+  sessionId: string
+  timeoutMs: number
+  predicate: (messages: SessionMessage[]) => boolean
+}): Promise<SessionMessage[]> {
+  const client = getOpencodeClientForTest(projectDirectory)
+  const start = Date.now()
+  while (Date.now() - start < timeoutMs) {
+    const response = await client.session.messages({
+      sessionID: sessionId,
+      directory: projectDirectory,
+    })
+    const messages = response.data ?? []
+    if (predicate(messages)) {
+      return messages
+    }
+    await new Promise<void>((resolve) => {
+      setTimeout(resolve, 100)
+    })
+  }
+
+  const finalResponse = await client.session.messages({
+    sessionID: sessionId,
+    directory: projectDirectory,
+  })
+  return finalResponse.data ?? []
+}
+
+describe('queue advanced: question tool answer', () => {
+  const ctx = setupQueueAdvancedSuite({
+    channelId: TEXT_CHANNEL_ID,
+    channelName: 'qa-question-e2e',
+    dirName: 'qa-question-e2e',
+    username: 'queue-question-tester',
+  })
+
+  afterEach(() => {
+    setDeterministicTranscription(null)
+  })
+
+  test('user text message dismisses pending question and enqueues as normal prompt', async () => {
+    await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+      content: 'QUESTION_TEXT_ANSWER_MARKER',
+    })
+
+    const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+      timeout: 8_000,
+      predicate: (t) => {
+        return t.name === 'QUESTION_TEXT_ANSWER_MARKER'
+      },
+    })
+
+    const th = ctx.discord.thread(thread.id)
+
+    // Wait for the question dropdown message to appear in Discord.
+    // This is the user-visible signal that the question tool fired and
+    // kimaki processed the event. Avoids polling internal Maps which
+    // have timing sensitivity on slower CI hardware.
+    await waitForBotMessageContaining({
+      discord: ctx.discord,
+      threadId: thread.id,
+      text: 'Which option do you prefer?',
+      timeout: 12_000,
+    })
+
+    // User sends a text message while question is pending.
+    // This should:
+    // 1. Dismiss the pending question (cleanup context)
+    // 2. Abort the blocked session so OpenCode unblocks
+    // 3. Enqueue the message as a normal user prompt (not consumed as answer)
+    await th.user(TEST_USER_ID).sendMessage({
+      content: 'my text answer',
+    })
+
+    // Give time for question cleanup to propagate
+    await new Promise((r) => {
+      setTimeout(r, 1_000)
+    })
+
+    const timeline = await th.text({ showInteractions: true })
+
+    // The user's text answer must appear in Discord
+    expect(timeline).toContain('my text answer')
+    // The original question must have appeared
+    expect(timeline).toContain('Which option do you prefer?')
+    // The user's marker message triggered the question
+    expect(timeline).toContain('QUESTION_TEXT_ANSWER_MARKER')
+  }, 20_000)
+})
+
+describe('queue advanced: voice message during pending question', () => {
+  const ctx = setupQueueAdvancedSuite({
+    channelId: VOICE_CHANNEL_ID,
+    channelName: 'qa-question-voice-e2e',
+    dirName: 'qa-question-voice-e2e',
+    username: 'queue-question-tester',
+  })
+
+  afterEach(() => {
+    setDeterministicTranscription(null)
+  })
+
+  test('voice message during pending question dismisses question and transcribes normally', async () => {
+    // This is the exact bug scenario: user sends a voice message while a
+    // question dropdown is pending. Voice messages have empty message.content
+    // (audio is in attachments, transcription happens later). The old code
+    // passed "" as the question answer and consumed the message — the voice
+    // content was completely lost.
+    await ctx.discord.channel(VOICE_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+      content: 'QUESTION_TEXT_ANSWER_MARKER',
+    })
+
+    const thread = await ctx.discord.channel(VOICE_CHANNEL_ID).waitForThread({
+      timeout: 8_000,
+      predicate: (t) => {
+        return t.name === 'QUESTION_TEXT_ANSWER_MARKER'
+      },
+    })
+
+    const th = ctx.discord.thread(thread.id)
+
+    // Wait for the question dropdown message to appear in Discord
+    await waitForBotMessageContaining({
+      discord: ctx.discord,
+      threadId: thread.id,
+      text: 'Which option do you prefer?',
+      timeout: 12_000,
+    })
+
+    // Send a voice message while the question is pending.
+    // Reproduction: Discord voice messages can still carry non-empty
+    // message.content. The bug consumed that raw text before transcription,
+    // so the session never received the spoken content.
+    setDeterministicTranscription({
+      transcription: 'I want option Alpha please',
+      queueMessage: false,
+    })
+
+    await th.user(TEST_USER_ID).sendVoiceMessage({
+      content: 'VOICE_TEXT_CONTENT_SHOULD_NOT_REACH_MODEL',
+    })
+
+    // Give time for question cleanup to propagate
+    await new Promise((r) => {
+      setTimeout(r, 1_000)
+    })
+
+    // Voice content should be transcribed and appear as the next user message,
+    // processed after the model responds to the empty question answer.
+    await waitForBotMessageContaining({
+      discord: ctx.discord,
+      threadId: thread.id,
+      text: 'I want option Alpha please',
+      timeout: 8_000,
+    })
+
+    await waitForFooterMessage({
+      discord: ctx.discord,
+      threadId: thread.id,
+      timeout: 8_000,
+      afterMessageIncludes: 'I want option Alpha please',
+      afterAuthorId: ctx.discord.botUserId,
+    })
+
+    const sessionId = await getThreadSession(thread.id)
+    expect(sessionId).toBeTruthy()
+
+    const sessionMessages = await waitForSessionMessages({
+      projectDirectory: ctx.directories.projectDirectory,
+      sessionId: sessionId!,
+      timeoutMs: 8_000,
+      predicate: (messages) => {
+        const timeline = getSessionRoleTextTimeline(messages)
+        return timeline.some((entry) => {
+          return entry.text.includes('I want option Alpha please')
+        })
+      },
+    })
+
+    const sessionTimeline = getSessionRoleTextTimeline(sessionMessages)
+    const sessionSummary = getSessionMessageSummary(sessionMessages)
+
+    const latestUserText = sessionTimeline
+      .filter((entry) => {
+        return entry.role === 'user'
+      })
+      .at(-1)?.text
+    const assistantTexts = sessionTimeline.flatMap((entry) => {
+      if (entry.role === 'assistant') {
+        return [entry.text]
+      }
+      return []
+    })
+
+    expect(latestUserText).toContain('I want option Alpha please')
+    expect(latestUserText).not.toContain('VOICE_TEXT_CONTENT_SHOULD_NOT_REACH_MODEL')
+    expect(assistantTexts).toContain('ok')
+    expect(
+      sessionSummary.some((message) => {
+        return message.role === 'user'
+          && message.parts.some((part) => {
+            return part.type === 'text' && part.text.includes('I want option Alpha please')
+          })
+      }),
+    ).toBe(true)
+    expect(
+      sessionSummary.some((message) => {
+        return message.role === 'assistant'
+          && message.parts.some((part) => {
+            return part.type === 'text' && part.text === 'ok'
+          })
+      }),
+    ).toBe(true)
+
+    const timeline = await th.text({ showInteractions: true })
+    expect(timeline).toContain('QUESTION_TEXT_ANSWER_MARKER')
+    expect(timeline).toContain('Which option do you prefer?')
+    expect(timeline).toContain('VOICE_TEXT_CONTENT_SHOULD_NOT_REACH_MODEL')
+    expect(timeline).toContain('🎤 Transcribing voice message...')
+    expect(timeline).toContain('📝 **Transcribed message:** I want option Alpha please')
+    expect(timeline).toContain('⬥ ok')
+
+    // Voice content must be present as a real transcribed message, not lost
+    expect(timeline).toContain('I want option Alpha please')
+  }, 20_000)
+})

package/src/queue-advanced-typing-interrupt.e2e.test.ts

@@ -0,0 +1,146 @@
+// E2e test for typing indicator lifecycle during interruption flow.
+// Split from queue-advanced-typing.e2e.test.ts for parallelization.
+
+import { describe, test, expect } from 'vitest'
+import {
+  setupQueueAdvancedSuite,
+  TEST_USER_ID,
+} from './queue-advanced-e2e-setup.js'
+import {
+  waitForBotMessageContaining,
+  waitForFooterMessage,
+} from './test-utils.js'
+
+const TEXT_CHANNEL_ID = '200000000000001008'
+
+const e2eTest = describe
+
+e2eTest('queue advanced: typing interrupt', () => {
+  const ctx = setupQueueAdvancedSuite({
+    channelId: TEXT_CHANNEL_ID,
+    channelName: 'qa-typing-interrupt-e2e',
+    dirName: 'qa-typing-interrupt-e2e',
+    username: 'queue-advanced-tester',
+  })
+
+  test(
+    'interruption flow emits footer for final assistant reply and then stops typing',
+    async () => {
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: typing-stop-interrupt-setup',
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: typing-stop-interrupt-setup'
+        },
+      })
+
+      const th = ctx.discord.thread(thread.id)
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: '*project',
+        timeout: 4_000,
+      })
+
+      th.clearTypingEvents()
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+      })
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'starting sleep 100',
+        afterUserMessageIncludes: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+        timeout: 4_000,
+      })
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: typing-stop-interrupt-final',
+      })
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'ok',
+        afterUserMessageIncludes: 'typing-stop-interrupt-final',
+        timeout: 12_000,
+      })
+
+      const messages = await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 12_000,
+        afterMessageIncludes: 'typing-stop-interrupt-final',
+        afterAuthorId: TEST_USER_ID,
+      })
+
+      const finalUserIndex = messages.findIndex((message) => {
+        return message.author.id === TEST_USER_ID
+          && message.content.includes('typing-stop-interrupt-final')
+      })
+      const finalReplyIndex = messages.findIndex((message, index) => {
+        if (index <= finalUserIndex) {
+          return false
+        }
+        return message.author.id === ctx.discord.botUserId && message.content.includes('ok')
+      })
+      const finalFooterIndex = messages.findIndex((message, index) => {
+        if (index <= finalReplyIndex) {
+          return false
+        }
+        return message.author.id === ctx.discord.botUserId
+          && message.content.startsWith('*')
+          && message.content.includes('⋅')
+      })
+
+      expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (queue-advanced-tester)
+        Reply with exactly: typing-stop-interrupt-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        --- from: user (queue-advanced-tester)
+        PLUGIN_TIMEOUT_SLEEP_MARKER
+        --- from: assistant (TestBot)
+        ⬥ starting sleep 100
+        --- from: user (queue-advanced-tester)
+        Reply with exactly: typing-stop-interrupt-final
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `)
+
+      const timeline = await th.text({ showTyping: true })
+      expect(finalUserIndex).toBeGreaterThanOrEqual(0)
+      expect(finalReplyIndex).toBeGreaterThan(finalUserIndex)
+      expect(finalFooterIndex).toBeGreaterThan(finalReplyIndex)
+      expect(messages[finalFooterIndex]).toBeDefined()
+
+      const finalPromptPosition = timeline.indexOf(
+        'Reply with exactly: typing-stop-interrupt-final',
+      )
+      const finalReplyPosition = timeline.indexOf('--- from: assistant (TestBot)\n⬥ ok', finalPromptPosition)
+      const lastFooterPosition = timeline.lastIndexOf('*project ⋅')
+      expect(finalPromptPosition).toBeGreaterThanOrEqual(0)
+      expect(finalReplyPosition).toBeGreaterThan(finalPromptPosition)
+      expect(lastFooterPosition).toBeGreaterThanOrEqual(0)
+      const typingDuringFinalRun = timeline
+        .slice(finalPromptPosition, finalReplyPosition)
+        .match(/\[bot typing\]/g) || []
+      expect(typingDuringFinalRun.length).toBeGreaterThanOrEqual(2)
+      expect(timeline.slice(lastFooterPosition)).not.toContain('[bot typing]')
+
+    },
+    12_000,
+  )
+
+})

package/src/queue-advanced-typing.e2e.test.ts

@@ -0,0 +1,199 @@
+// E2e tests for typing indicator lifecycle in advanced queue scenarios.
+// Split from thread-queue-advanced.e2e.test.ts for parallelization.
+
+import { describe, test, expect } from 'vitest'
+import {
+  setupQueueAdvancedSuite,
+  TEST_USER_ID,
+} from './queue-advanced-e2e-setup.js'
+import {
+  waitForBotMessageContaining,
+  waitForFooterMessage,
+} from './test-utils.js'
+
+const TEXT_CHANNEL_ID = '200000000000001002'
+
+const e2eTest = describe
+
+e2eTest('queue advanced: typing lifecycle', () => {
+  const ctx = setupQueueAdvancedSuite({
+    channelId: TEXT_CHANNEL_ID,
+    channelName: 'qa-typing-e2e',
+    dirName: 'qa-typing-e2e',
+    username: 'queue-advanced-tester',
+  })
+
+  test(
+    'normal reply stops typing after footer',
+    async () => {
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: typing-stop-normal',
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: typing-stop-normal'
+        },
+      })
+
+      const th = ctx.discord.thread(thread.id)
+
+      await th.waitForTypingEvent({ timeout: 1_000 }).catch(() => {
+        return undefined
+      })
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'ok',
+        timeout: 4_000,
+      })
+
+      const messages = await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 4_000,
+        afterMessageIncludes: 'ok',
+        afterAuthorId: ctx.discord.botUserId,
+      })
+
+      const replyIndex = messages.findIndex((message) => {
+        return message.author.id === ctx.discord.botUserId && message.content.includes('ok')
+      })
+      const footerIndex = messages.findIndex((message, index) => {
+        if (index <= replyIndex) {
+          return false
+        }
+        return message.author.id === ctx.discord.botUserId
+          && message.content.startsWith('*')
+          && message.content.includes('⋅')
+      })
+
+      const timeline = await th.text({ showTyping: true })
+      expect(timeline).toContain('Reply with exactly: typing-stop-normal')
+      expect(timeline).toContain('⬥ ok')
+      expect(timeline).toContain('*project ⋅ main ⋅')
+      const typingCount = (timeline.match(/\[bot typing\]/g) || []).length
+      expect(typingCount).toBeGreaterThanOrEqual(1)
+      expect(replyIndex).toBeGreaterThanOrEqual(0)
+      expect(footerIndex).toBeGreaterThan(replyIndex)
+      expect(messages[footerIndex]).toBeDefined()
+
+      const lastFooterPosition = timeline.lastIndexOf('*project ⋅')
+      expect(lastFooterPosition).toBeGreaterThanOrEqual(0)
+      expect(timeline.slice(lastFooterPosition)).not.toContain('[bot typing]')
+
+    },
+    8_000,
+  )
+
+  test(
+    'thread follow-up reply re-pulses typing after a visible assistant message while session stays busy',
+    async () => {
+      await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+        content: 'Reply with exactly: typing-thread-reply-setup',
+      })
+
+      const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+        timeout: 4_000,
+        predicate: (t) => {
+          return t.name === 'Reply with exactly: typing-thread-reply-setup'
+        },
+      })
+
+      const th = ctx.discord.thread(thread.id)
+
+      await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'ok',
+        timeout: 4_000,
+      })
+
+      await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 4_000,
+        afterMessageIncludes: 'ok',
+        afterAuthorId: ctx.discord.botUserId,
+      })
+
+      th.clearTypingEvents()
+
+      await th.user(TEST_USER_ID).sendMessage({
+        content: 'TYPING_REPULSE_MARKER',
+      })
+
+      const messagesAfterFirstReply = await waitForBotMessageContaining({
+        discord: ctx.discord,
+        threadId: thread.id,
+        userId: TEST_USER_ID,
+        text: 'repulse-first',
+        afterUserMessageIncludes: 'TYPING_REPULSE_MARKER',
+        timeout: 4_000,
+      })
+
+      const markerUserIndex = messagesAfterFirstReply.findIndex((message) => {
+        return message.author.id === TEST_USER_ID
+          && message.content.includes('TYPING_REPULSE_MARKER')
+      })
+      const firstReply = messagesAfterFirstReply.find((message, index) => {
+        if (index <= markerUserIndex) {
+          return false
+        }
+        return message.author.id === ctx.discord.botUserId
+          && message.content.includes('repulse-first')
+      })
+      if (!firstReply) {
+        throw new Error('Expected first bot reply after TYPING_REPULSE_MARKER')
+      }
+
+      const typingAfterVisibleReply = await th.waitForTypingEvent({
+        timeout: 700,
+        afterTimestamp: new Date(firstReply.timestamp).getTime(),
+      }).then(
+        () => {
+          return true
+        },
+        () => {
+          return false
+        },
+      )
+
+      const messages = await waitForFooterMessage({
+        discord: ctx.discord,
+        threadId: thread.id,
+        timeout: 6_000,
+        afterMessageIncludes: 'TYPING_REPULSE_MARKER',
+        afterAuthorId: TEST_USER_ID,
+      })
+
+      const timeline = await th.text({ showTyping: true })
+      expect(timeline).toContain('TYPING_REPULSE_MARKER')
+      expect(timeline).toContain('⬥ repulse-first')
+      const typingCount = (timeline.match(/\[bot typing\]/g) || []).length
+      expect(typingCount).toBeGreaterThanOrEqual(2)
+
+      const followupUserIndex = messages.findIndex((message) => {
+        return message.author.id === TEST_USER_ID
+          && message.content.includes('TYPING_REPULSE_MARKER')
+      })
+      const followupReplyIndex = messages.findIndex((message, index) => {
+        if (index <= followupUserIndex) {
+          return false
+        }
+        return message.author.id === ctx.discord.botUserId
+          && message.content.includes('repulse-first')
+      })
+
+      expect(followupUserIndex).toBeGreaterThanOrEqual(0)
+      expect(followupReplyIndex).toBeGreaterThan(followupUserIndex)
+      expect(typingAfterVisibleReply).toBe(true)
+    },
+    10_000,
+  )
+
+})