fix: Honor a Submit Shortcut Rebound Off Enter in Ask Answer Fields

The window shortcut handler yields submitMessage in every editing field
except the composer, so a chord such as Ctrl+J did nothing in the ask
answer fields. Both the single-question answer box and the batched
answer field now act on it, through a shared isReboundSubmitChord.

Author: berry-13

client/src/components/Chat/Messages/Content/AskUserQuestion.tsx

@@ -4,10 +4,10 @@ import { ChevronDown, MessageCircleQuestion, TriangleAlert } from 'lucide-react'
 import type { Agents } from 'librechat-data-provider';
 import type { KeyboardEvent } from 'react';
 import type { ComposerBindings } from '~/hooks/Input/useComposerBindings';
+import { isCancelKey, isReboundSubmitChord, resolveComposerKeyDown } from '~/utils/shortcuts';
 import { useApprovalContext, useAskSubmitStatus, useResumeSubmit } from './ApprovalContext';
 import { splitOtherOption, ASK_USER_DECLINED_ANSWER } from '~/utils/approval';
 import { useOptionalChatSurface } from '~/components/Chat/Subagents/surface';
-import { isCancelKey, resolveComposerKeyDown } from '~/utils/shortcuts';
 import { cn, forceResize, insertTextAtCursor } from '~/utils';
 import useAskAnswerMode from '~/hooks/Input/useAskAnswerMode';
 import AskOptions from '~/components/Chat/ask/options';
@@ -240,8 +240,16 @@ function AskUserQuestionSingle({
    * steer/queue actions.
    */
   const handleAnswerKeyDown = (e: KeyboardEvent<HTMLTextAreaElement>) => {
+    const isComposing = e.nativeEvent.isComposing || e.key === 'Process' || e.keyCode === 229;
+    if (!isComposing && isReboundSubmitChord(e.nativeEvent, { shortcutsEnabled, submitOverride })) {
+      e.preventDefault();
+      if (canSubmit && !locked) {
+        submitCombined();
+      }
+      return;
+    }
     const action = resolveComposerKeyDown(e.nativeEvent, {
-      isComposing: e.nativeEvent.isComposing || e.key === 'Process' || e.keyCode === 229,
+      isComposing,
       isSubmitting: false,
       allowSubmitWhileGenerating: false,
       hasDuringRunModifier: false,

client/src/components/Chat/Messages/Content/AskUserQuestions.tsx

@@ -3,10 +3,11 @@ import { TriangleAlert } from 'lucide-react';
 import { Input, Button } from '@librechat/client';
 import type { Agents } from 'librechat-data-provider';
 import type { KeyboardEvent, ReactNode } from 'react';
+import { useOptionalChatSurface } from '~/components/Chat/Subagents/surface';
+import { isCancelKey, isReboundSubmitChord } from '~/utils/shortcuts';
 import useAskQuestionsForm from '~/hooks/Input/useAskQuestionsForm';
 import AskOptions from '~/components/Chat/ask/options';
 import { splitOtherOption } from '~/utils/approval';
-import { isCancelKey } from '~/utils/shortcuts';
 import { AutoHeight } from '~/components/ui';
 import { mainTextareaId } from '~/common';
 import { useLocalize } from '~/hooks';
@@ -41,6 +42,7 @@ export default function AskUserQuestions({
   const localize = useLocalize();
   const promptId = useId();
   const form = useAskQuestionsForm(actionId, questions);
+  const composerBindings = useOptionalChatSurface()?.composerBindings;
   const { goToStep, selectOption } = form;
 
   const scrollRef = useRef<HTMLDivElement>(null);
@@ -331,16 +333,26 @@ export default function AskUserQuestions({
                 /* The composer popover sits inside the chat form, where Enter in a
                    single-line field would submit the composer draft instead.
                    Enter (or Ctrl/Cmd+Enter) confirms this answer: the next step,
-                   or the batch. Shift+Enter and Alt+Enter never submit, as in the
+                   or the batch, and so does a submit shortcut rebound off Enter.
+                   Shift+Enter and Alt+Enter never submit, as in the
                    composer, and neither does a held Enter repeating into the next
                    step; those are still kept from submitting the form. An Enter
                    that confirms an IME composition is left alone, with the same
                    Safari fallback as the composer. */
+                const composing =
+                  event.nativeEvent.isComposing || event.nativeEvent.keyCode === 229;
                 if (
-                  event.key !== 'Enter' ||
-                  event.nativeEvent.isComposing ||
-                  event.nativeEvent.keyCode === 229
+                  !composing &&
+                  composerBindings != null &&
+                  isReboundSubmitChord(event.nativeEvent, composerBindings)
                 ) {
+                  event.preventDefault();
+                  if (!event.repeat) {
+                    confirmStep();
+                  }
+                  return;
+                }
+                if (event.key !== 'Enter' || composing) {
                   return;
                 }
                 event.preventDefault();

client/src/components/Chat/Messages/Content/__tests__/AskUserQuestion.test.tsx

@@ -2,6 +2,7 @@ import React from 'react';
 import { RecoilRoot } from 'recoil';
 import { fireEvent, render, screen } from '@testing-library/react';
 import type { Agents } from 'librechat-data-provider';
+import type { ShortcutBinding } from '~/utils/shortcuts';
 import { ChatSurfaceProvider } from '~/components/Chat/Subagents/surface';
 import { ASK_USER_DECLINED_ANSWER } from '~/utils/approval';
 import ApprovalProvider from '../ApprovalContext';
@@ -67,6 +68,7 @@ jest.mock('~/Providers/ChatContext', () => ({
 }));
 
 const yieldedChords = new Set<string>();
+let submitOverride: ShortcutBinding | undefined;
 
 const tree = (
   key: string,
@@ -79,7 +81,7 @@ const tree = (
         enterToSend,
         maximizeChatSpace: false,
         showScrollButton: false,
-        composerBindings: { shortcutsEnabled: true, submitOverride: undefined, yieldedChords },
+        composerBindings: { shortcutsEnabled: true, submitOverride, yieldedChords },
         claimForeground: jest.fn(),
         handOffComposerText: jest.fn(),
       }}
@@ -99,6 +101,7 @@ describe('AskUserQuestion', () => {
     mockLiveActionId = null;
     mockChecked = [];
     mockAnswerText = '';
+    submitOverride = undefined;
   });
 
   test('restores a typed answer after the card remounts inside the same message', () => {
@@ -175,6 +178,13 @@ describe('AskUserQuestion', () => {
       expect(mockSubmitAnswer).not.toHaveBeenCalled();
     });
 
+    test('a submit shortcut rebound off Enter submits the answer', () => {
+      submitOverride = { meta: false, ctrl: true, alt: false, shift: false, key: 'J' };
+      render(liveTree(true));
+      fireEvent.keyDown(answerBox(), { key: 'j', ctrlKey: true });
+      expect(mockSubmitAnswer).toHaveBeenCalledWith(['Use staging first']);
+    });
+
     test('does not submit an empty answer', () => {
       render(liveTree(true, '   '));
       fireEvent.keyDown(answerBox(), { key: 'Enter' });

client/src/components/Chat/Messages/Content/__tests__/AskUserQuestions.test.tsx

@@ -2,6 +2,7 @@ import React from 'react';
 import { RecoilRoot } from 'recoil';
 import { fireEvent, render, screen } from '@testing-library/react';
 import type { Agents } from 'librechat-data-provider';
+import { ChatSurfaceProvider } from '~/components/Chat/Subagents/surface';
 import { ASK_USER_DECLINED_ANSWER } from '~/utils/approval';
 import AskUserQuestions from '../AskUserQuestions';
 
@@ -326,6 +327,38 @@ describe('AskUserQuestions', () => {
     expect(onSubmit).not.toHaveBeenCalled();
   });
 
+  test('a submit shortcut rebound off Enter confirms the answer like Enter', () => {
+    render(
+      <RecoilRoot>
+        <ChatSurfaceProvider
+          value={{
+            enterToSend: false,
+            maximizeChatSpace: false,
+            showScrollButton: false,
+            composerBindings: {
+              shortcutsEnabled: true,
+              submitOverride: { meta: false, ctrl: true, alt: false, shift: false, key: 'J' },
+              yieldedChords: new Set(),
+            },
+            claimForeground: jest.fn(),
+            handOffComposerText: jest.fn(),
+          }}
+        >
+          <AskUserQuestions actionId="ask-rebound-submit" questions={questions} />
+        </ChatSurfaceProvider>
+      </RecoilRoot>,
+    );
+    const first = screen.getByRole('textbox', { name: /Where should this run/ });
+    fireEvent.change(first, { target: { value: 'Locally' } });
+    fireEvent.keyDown(first, { key: 'j', ctrlKey: true });
+    expect(isShown('Which time window?')).toBe(true);
+
+    const last = screen.getByRole('textbox', { name: /Which time window/ });
+    fireEvent.change(last, { target: { value: 'Today' } });
+    fireEvent.keyDown(last, { key: 'j', ctrlKey: true });
+    expect(mockSubmitAskAnswer).toHaveBeenCalledTimes(1);
+  });
+
   describe('focus on arrival', () => {
     afterEach(() => {
       document.getElementById('prompt-textarea')?.remove();

client/src/utils/shortcuts.spec.ts

@@ -2,6 +2,7 @@ import type { ShortcutBinding, ComposerKeyContext } from './shortcuts';
 import {
   hasModifier,
   isCancelKey,
+  isReboundSubmitChord,
   bindingHash,
   normalizeKey,
   parseBinding,
@@ -222,6 +223,46 @@ describe('resolveSubmitOverrideAction', () => {
   });
 });
 
+describe('isReboundSubmitChord', () => {
+  const ctrlJ = makeBinding({ ctrl: true, key: 'J' });
+  const press = (init: KeyboardEventInit) => new KeyboardEvent('keydown', init);
+
+  it('matches a submit chord rebound off Enter', () => {
+    expect(
+      isReboundSubmitChord(press({ key: 'j', ctrlKey: true }), {
+        shortcutsEnabled: true,
+        submitOverride: ctrlJ,
+      }),
+    ).toBe(true);
+  });
+
+  it('leaves Enter chords, other keys, unset or unbound overrides and disabled shortcuts alone', () => {
+    const ctrlEnter = makeBinding({ ctrl: true, key: 'Enter' });
+    const event = press({ key: 'j', ctrlKey: true });
+    expect(
+      isReboundSubmitChord(press({ key: 'Enter', ctrlKey: true }), {
+        shortcutsEnabled: true,
+        submitOverride: ctrlEnter,
+      }),
+    ).toBe(false);
+    expect(
+      isReboundSubmitChord(press({ key: 'k', ctrlKey: true }), {
+        shortcutsEnabled: true,
+        submitOverride: ctrlJ,
+      }),
+    ).toBe(false);
+    expect(isReboundSubmitChord(event, { shortcutsEnabled: true, submitOverride: undefined })).toBe(
+      false,
+    );
+    expect(isReboundSubmitChord(event, { shortcutsEnabled: true, submitOverride: null })).toBe(
+      false,
+    );
+    expect(isReboundSubmitChord(event, { shortcutsEnabled: false, submitOverride: ctrlJ })).toBe(
+      false,
+    );
+  });
+});
+
 describe('isCancelKey', () => {
   it('is true for a bare Escape press', () => {
     expect(isCancelKey(new KeyboardEvent('keydown', { key: 'Escape' }))).toBe(true);

client/src/utils/shortcuts.ts

@@ -321,6 +321,23 @@ export function resolveComposerKeyDown(
   return 'none';
 }
 
+/**
+ * A `submitMessage` chord rebound off Enter. The window-level handler yields
+ * it in every editing field but the composer, so an answer field that submits
+ * like the composer has to act on it itself; Enter chords go through
+ * `resolveComposerKeyDown`.
+ */
+export function isReboundSubmitChord(
+  e: KeyChordSource,
+  ctx: Pick<ComposerKeyContext, 'shortcutsEnabled' | 'submitOverride'>,
+): boolean {
+  const { submitOverride } = ctx;
+  if (!ctx.shortcutsEnabled || submitOverride == null || submitOverride.key === 'Enter') {
+    return false;
+  }
+  return bindingsMatch(bindingFromEvent(e), submitOverride);
+}
+
 export function isCancelKey(e: KeyboardEvent): boolean {
   return e.key === 'Escape' && !e.metaKey && !e.ctrlKey && !e.altKey && !e.shiftKey;
 }