@otto-assistant/bridge 0.4.92

package/dist/queue-advanced-abort.e2e.test.js

@@ -0,0 +1,293 @@
+// E2e tests for abort, model-switch, and retry 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 { getRuntime, } from './session-handler/thread-session-runtime.js';
+import { getThreadState } from './session-handler/thread-runtime-state.js';
+import { setSessionModel } from './database.js';
+import { waitForFooterMessage, waitForBotMessageContaining, waitForBotReplyAfterUserMessage, } from './test-utils.js';
+const TEXT_CHANNEL_ID = '200000000000001003';
+const e2eTest = describe;
+e2eTest('queue advanced: abort and retry', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-abort-e2e',
+        dirName: 'qa-abort-e2e',
+        username: 'queue-advanced-tester',
+    });
+    test('slow tool call (sleep) gets aborted by explicit abort, then queue continues', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: oscar',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: oscar';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        const firstReply = await th.waitForBotReply({ timeout: 4_000 });
+        expect(firstReply.content.trim().length).toBeGreaterThan(0);
+        // Wait for the first completion footer so it lands in a deterministic position
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 4_000,
+        });
+        const before = await th.getMessages();
+        const beforeBotCount = before.filter((m) => {
+            return m.author.id === ctx.discord.botUserId;
+        }).length;
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+        });
+        // The matcher emits "starting sleep 100" text before the long delay.
+        // Wait for it to land in Discord BEFORE aborting so the message is in a
+        // deterministic position and the abort produces no further stray messages.
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'starting sleep',
+            afterUserMessageIncludes: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+            timeout: 4_000,
+        });
+        const runtime = getRuntime(thread.id);
+        expect(runtime).toBeDefined();
+        if (!runtime) {
+            throw new Error('Expected runtime to exist for explicit-abort test');
+        }
+        runtime.abortActiveRun('test-explicit-abort');
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: papa',
+        });
+        const after = await waitForBotReplyAfterUserMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            userMessageIncludes: 'papa',
+            timeout: 8_000,
+        });
+        const afterBotMessages = after.filter((m) => {
+            return m.author.id === ctx.discord.botUserId;
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 8_000,
+            afterMessageIncludes: 'papa',
+            afterAuthorId: TEST_USER_ID,
+        });
+        // Assert ordering invariants instead of exact snapshot — the papa reply
+        // and footer can interleave non-deterministically.
+        const timeline = await th.text();
+        expect(timeline).toContain('Reply with exactly: oscar');
+        expect(timeline).toContain('PLUGIN_TIMEOUT_SLEEP_MARKER');
+        expect(timeline).toContain('⬥ starting sleep 100');
+        expect(timeline).toContain('Reply with exactly: papa');
+        expect(timeline).toContain('*project ⋅ main ⋅');
+        // oscar comes before the sleep marker, sleep before papa
+        const oscarIdx = timeline.indexOf('oscar');
+        const sleepIdx = timeline.indexOf('PLUGIN_TIMEOUT_SLEEP_MARKER');
+        const papaIdx = timeline.indexOf('papa');
+        expect(oscarIdx).toBeLessThan(sleepIdx);
+        expect(sleepIdx).toBeLessThan(papaIdx);
+        expect(afterBotMessages.length).toBeGreaterThanOrEqual(beforeBotCount + 1);
+        const sleepToolIndex = after.findIndex((m) => {
+            return (m.author.id === TEST_USER_ID &&
+                m.content.includes('PLUGIN_TIMEOUT_SLEEP_MARKER'));
+        });
+        expect(sleepToolIndex).toBeGreaterThan(-1);
+        const userPapaIndex = after.findIndex((m) => {
+            return m.author.id === TEST_USER_ID && m.content.includes('papa');
+        });
+        expect(userPapaIndex).toBeGreaterThan(-1);
+        expect(sleepToolIndex).toBeLessThan(userPapaIndex);
+        const lastBotIndex = after.findLastIndex((m) => {
+            return m.author.id === ctx.discord.botUserId;
+        });
+        expect(userPapaIndex).toBeLessThan(lastBotIndex);
+    }, 12_000);
+    test('explicit abort emits MessageAbortedError and does not emit footer', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: abort-no-footer-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: abort-no-footer-setup';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        await th.waitForBotReply({ timeout: 4_000 });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: '⋅',
+            timeout: 4_000,
+        });
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'SLOW_ABORT_MARKER run long response',
+        });
+        const runtime = getRuntime(thread.id);
+        expect(runtime).toBeDefined();
+        if (!runtime) {
+            throw new Error('Expected runtime to exist for abort no-footer test');
+        }
+        const beforeAbortMessages = await th.getMessages();
+        const baselineCount = beforeAbortMessages.length;
+        runtime.abortActiveRun('test-no-footer-on-abort');
+        for (let i = 0; i < 10; i++) {
+            await new Promise((resolve) => {
+                setTimeout(resolve, 20);
+            });
+            const msgs = await th.getMessages();
+            const newMsgs = msgs.slice(baselineCount);
+            const hasFooter = newMsgs.some((m) => {
+                return m.author.id === ctx.discord.botUserId
+                    && m.content.startsWith('*')
+                    && m.content.includes('⋅');
+            });
+            expect(hasFooter).toBe(false);
+        }
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (queue-advanced-tester)
+        Reply with exactly: abort-no-footer-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        --- from: user (queue-advanced-tester)
+        SLOW_ABORT_MARKER run long response"
+      `);
+    }, 10_000);
+    test.skip('explicit abort stale-idle window: follow-up prompt still gets assistant text', async () => {
+        const setupPrompt = 'Reply with exactly: race-setup-1';
+        const raceFinalPrompt = 'Reply with exactly: race-final-1';
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: setupPrompt,
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === setupPrompt;
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        const setupReply = await th.waitForBotReply({ timeout: 4_000 });
+        expect(setupReply.content.trim().length).toBeGreaterThan(0);
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'SLOW_ABORT_MARKER run long response',
+        });
+        const runtime = getRuntime(thread.id);
+        expect(runtime).toBeDefined();
+        if (!runtime) {
+            throw new Error('Expected runtime to exist for race abort scenario');
+        }
+        runtime.abortActiveRun('test-race-abort');
+        await th.user(TEST_USER_ID).sendMessage({
+            content: raceFinalPrompt,
+        });
+        await waitForBotReplyAfterUserMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            userMessageIncludes: raceFinalPrompt,
+            timeout: 4_000,
+        });
+    }, 8_000);
+    test('model switch mid-session aborts and restarts from same session history', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: retry-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: retry-setup';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        const firstReply = await th.waitForBotReply({ timeout: 4_000 });
+        expect(firstReply.content.trim().length).toBeGreaterThan(0);
+        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',
+            afterUserMessageIncludes: 'PLUGIN_TIMEOUT_SLEEP_MARKER',
+            timeout: 4_000,
+        });
+        const sessionId = getThreadState(thread.id)?.sessionId;
+        expect(sessionId).toBeDefined();
+        if (!sessionId) {
+            throw new Error('Expected active session id for model switch test');
+        }
+        await setSessionModel({
+            sessionId,
+            modelId: 'deterministic-provider/deterministic-v3',
+            variant: null,
+        });
+        const runtime = getRuntime(thread.id);
+        expect(runtime).toBeDefined();
+        if (!runtime) {
+            throw new Error('Expected runtime to exist for model switch test');
+        }
+        const retried = await runtime.retryLastUserPrompt();
+        expect(retried).toBe(true);
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: model-switch-followup',
+        });
+        await waitForBotReplyAfterUserMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            userMessageIncludes: 'model-switch-followup',
+            timeout: 4_000,
+        });
+        // Wait for potential footer to arrive (race between step-finish interrupt
+        // and model switch settling means footer may or may not appear).
+        await new Promise((resolve) => {
+            setTimeout(resolve, 200);
+        });
+        const text = await th.text();
+        // The follow-up reply ("ok") must be present with deterministic-v3
+        expect(text).toContain('Reply with exactly: model-switch-followup');
+        expect(text).toContain('⬥ ok');
+        // The old sleep text should be visible from the first turn
+        expect(text).toContain('starting sleep 100');
+    }, 10_000);
+    test('abortActiveRun settles correctly during long-running request', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: force-abort-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: force-abort-setup';
+            },
+        });
+        const th = ctx.discord.thread(thread.id);
+        const setupReply = await th.waitForBotReply({ timeout: 4_000 });
+        expect(setupReply.content.trim().length).toBeGreaterThan(0);
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'SLOW_ABORT_MARKER run long response',
+        });
+        const runtime = getRuntime(thread.id);
+        expect(runtime).toBeDefined();
+        if (!runtime) {
+            throw new Error('Expected runtime to exist for forced-abort test');
+        }
+        runtime.abortActiveRun('force-abort-test');
+        expect(await th.text()).toMatchInlineSnapshot(`
+        "--- from: user (queue-advanced-tester)
+        Reply with exactly: force-abort-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        --- from: user (queue-advanced-tester)
+        SLOW_ABORT_MARKER run long response"
+      `);
+    }, 10_000);
+});

package/dist/queue-advanced-action-buttons.e2e.test.js

@@ -0,0 +1,206 @@
+// E2e regression test for action button click continuation in thread sessions.
+// Reproduces the bug where button click interaction acks but the session does not continue.
+import { describe, test, expect } from 'vitest';
+import { setupQueueAdvancedSuite, TEST_USER_ID, } from './queue-advanced-e2e-setup.js';
+import { waitForBotMessageContaining, waitForFooterMessage, } from './test-utils.js';
+import { getThreadSession } from './database.js';
+import { pendingActionButtonContexts, showActionButtons, } from './commands/action-buttons.js';
+const TEXT_CHANNEL_ID = '200000000000001006';
+async function waitForPendingActionButtons({ threadId, timeoutMs, }) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const entry = [...pendingActionButtonContexts.entries()].find(([, context]) => {
+            return context.thread.id === threadId && Boolean(context.messageId);
+        });
+        if (entry) {
+            const [contextHash, context] = entry;
+            if (context.messageId) {
+                return { contextHash, messageId: context.messageId };
+            }
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 100);
+        });
+    }
+    throw new Error('Timed out waiting for pending action buttons context');
+}
+async function waitForNoPendingActionButtons({ threadId, timeoutMs, }) {
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        const stillPending = [...pendingActionButtonContexts.values()].some((context) => {
+            return context.thread.id === threadId;
+        });
+        if (!stillPending) {
+            return;
+        }
+        await new Promise((resolve) => {
+            setTimeout(resolve, 100);
+        });
+    }
+    throw new Error('Timed out waiting for action buttons cleanup');
+}
+describe('queue advanced: action buttons', () => {
+    const ctx = setupQueueAdvancedSuite({
+        channelId: TEXT_CHANNEL_ID,
+        channelName: 'qa-action-buttons-e2e',
+        dirName: 'qa-action-buttons-e2e',
+        username: 'queue-action-tester',
+    });
+    test('button click should continue the session with a follow-up assistant reply', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: action-button-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: action-button-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,
+        });
+        const currentSessionId = await getThreadSession(thread.id);
+        if (!currentSessionId) {
+            throw new Error('Expected thread session id before showing action buttons');
+        }
+        const channel = await ctx.botClient.channels.fetch(thread.id);
+        if (!channel || !channel.isThread()) {
+            throw new Error('Expected Discord thread channel for action button test');
+        }
+        await showActionButtons({
+            thread: channel,
+            sessionId: currentSessionId,
+            directory: ctx.directories.projectDirectory,
+            buttons: [{ label: 'Continue action-buttons flow', color: 'green' }],
+        });
+        const action = await waitForPendingActionButtons({
+            threadId: thread.id,
+            timeoutMs: 12_000,
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            userId: TEST_USER_ID,
+            text: 'Action Required',
+            timeout: 12_000,
+        });
+        const interaction = await th.user(TEST_USER_ID).clickButton({
+            messageId: action.messageId,
+            customId: `action_button:${action.contextHash}:0`,
+        });
+        await th.waitForInteractionAck({
+            interactionId: interaction.id,
+            timeout: 4_000,
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'action-buttons-click-continued',
+            timeout: 12_000,
+        });
+        await waitForFooterMessage({
+            discord: ctx.discord,
+            threadId: thread.id,
+            timeout: 12_000,
+            afterMessageIncludes: 'action-buttons-click-continued',
+            afterAuthorId: ctx.discord.botUserId,
+        });
+        const timeline = await th.text({ showInteractions: true });
+        expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (queue-action-tester)
+        Reply with exactly: action-button-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        **Action Required**
+        _Selected: Continue action-buttons flow_
+        [user clicks button]
+        ⬥ action-buttons-click-continued
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*"
+      `);
+        expect(timeline).toContain('action-buttons-click-continued');
+    }, 20_000);
+    test('manual thread message dismisses pending action buttons', async () => {
+        await ctx.discord.channel(TEXT_CHANNEL_ID).user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: action-button-dismiss-setup',
+        });
+        const thread = await ctx.discord.channel(TEXT_CHANNEL_ID).waitForThread({
+            timeout: 4_000,
+            predicate: (t) => {
+                return t.name === 'Reply with exactly: action-button-dismiss-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,
+        });
+        const currentSessionId = await getThreadSession(thread.id);
+        if (!currentSessionId) {
+            throw new Error('Expected thread session id before showing action buttons');
+        }
+        const channel = await ctx.botClient.channels.fetch(thread.id);
+        if (!channel || !channel.isThread()) {
+            throw new Error('Expected Discord thread channel for action button test');
+        }
+        await showActionButtons({
+            thread: channel,
+            sessionId: currentSessionId,
+            directory: ctx.directories.projectDirectory,
+            buttons: [{ label: 'Dismiss me', color: 'white' }],
+        });
+        await waitForPendingActionButtons({
+            threadId: thread.id,
+            timeoutMs: 4_000,
+        });
+        await th.user(TEST_USER_ID).sendMessage({
+            content: 'Reply with exactly: post-dismiss-user-message',
+        });
+        await waitForBotMessageContaining({
+            discord: ctx.discord,
+            threadId: thread.id,
+            text: 'Buttons dismissed.',
+            timeout: 4_000,
+        });
+        await waitForNoPendingActionButtons({
+            threadId: thread.id,
+            timeoutMs: 4_000,
+        });
+        const timeline = await th.text({ showInteractions: true });
+        expect(timeline).toMatchInlineSnapshot(`
+        "--- from: user (queue-action-tester)
+        Reply with exactly: action-button-dismiss-setup
+        --- from: assistant (TestBot)
+        ⬥ ok
+        *project ⋅ main ⋅ Ns ⋅ N% ⋅ deterministic-v2*
+        **Action Required**
+        _Buttons dismissed._
+        --- from: user (queue-action-tester)
+        Reply with exactly: post-dismiss-user-message"
+      `);
+        expect(timeline).toContain('_Buttons dismissed._');
+        expect(timeline).toContain('post-dismiss-user-message');
+    }, 20_000);
+});