Skip to content

DeepTutor: Lifelong Personalized Tutoring. https://deeptutor.info/.

fix(chat): share keyboard and button submission admission

dajiaohuangb4a3c9c41da3
diff --git a/web/components/chat/home/ChatComposer.tsx b/web/components/chat/home/ChatComposer.tsx
index 073f83f20..671e32674 100644
--- a/web/components/chat/home/ChatComposer.tsx
+++ b/web/components/chat/home/ChatComposer.tsx
@@ -654,6 +654,13 @@ export default memo(function ChatComposer({
const doSend = useCallback(
(content: string) => {
+ // Keyboard and button submissions share the same admission checks.
+ // A refused submission must leave the draft in the input.
+ if (isStreaming && !awaitingUserReply) return false;
+ if (capabilityNeedsConfig && !capabilityConfigConfirmed) {
+ onRequestConfigConfirm();
+ return false;
+ }
onSend(content);
void saveWorkspaceDraft({ text: "", attachments: [] }).catch(() => {});
setHasContent(false);
@@ -662,8 +669,10 @@ export default memo(function ChatComposer({
// composer into the conversation layout. Restore it after that update
// so the user can keep typing, including after switching back to the tab.
focusTextarea();
+ return true;
},
- [focusTextarea, onSend],
+ [awaitingUserReply, capabilityConfigConfirmed, capabilityNeedsConfig,
+ focusTextarea, isStreaming, onRequestConfigConfirm, onSend],
);
const hasReferences =
@@ -1037,7 +1046,7 @@ export default memo(function ChatComposer({
ref={inputHandleRef}
textareaRef={textareaRef}
isVisualizeMode={isVisualizeMode}
- isStreaming={isStreaming}
+ isStreaming={streamingBlocksSend}
canSendEmpty={hasReferences}
onSend={doSend}
onInputChange={handleInputChange}
diff --git a/web/components/chat/home/ComposerInput.tsx b/web/components/chat/home/ComposerInput.tsx
index e47d602d7..0fb6422c3 100644
--- a/web/components/chat/home/ComposerInput.tsx
+++ b/web/components/chat/home/ComposerInput.tsx
@@ -30,7 +30,7 @@ interface ComposerInputProps {
// send even if the text body is empty. Without this, Enter would silently
// do nothing for an attachment-only message.
canSendEmpty: boolean;
- onSend: (content: string) => void;
+ onSend: (content: string) => boolean | void;
onInputChange: (content: string) => void;
onPaste: (e: React.ClipboardEvent) => void;
selectedCounts: ChatSpaceSelectionCounts;
@@ -326,7 +326,7 @@ export const ComposerInput = memo(
// references queued (canSendEmpty). This matches the send-button's
// own enablement logic in ChatComposer (`canSend`).
if (!content && !canSendEmpty) return;
- onSend(content);
+ if (onSend(content) === false) return;
setInputBoth("");
onInputChange("");
setShowAtPopup(false);
diff --git a/web/tests/composer-keyboard-admission.spec.tsx b/web/tests/composer-keyboard-admission.spec.tsx
new file mode 100644
index 000000000..78c5d38d8
--- /dev/null
+++ b/web/tests/composer-keyboard-admission.spec.tsx
@@ -0,0 +1,79 @@
+import { createRef, type ComponentProps } from "react";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { expect, it, vi } from "vitest";
+import { MessageSquare } from "lucide-react";
+
+import ChatComposer from "@/components/chat/home/ChatComposer";
+
+vi.mock("react-i18next", () => ({
+ useTranslation: () => ({ t: (key: string) => key }),
+}));
+vi.mock("@/lib/workspace-drafts", () => ({
+ readWorkspaceDraft: async () => null,
+ saveWorkspaceDraft: async () => undefined,
+}));
+
+function composer(overrides: Partial<ComponentProps<typeof ChatComposer>> = {}) {
+ const onSend = vi.fn();
+ const onRequestConfigConfirm = vi.fn();
+ const noop = () => undefined;
+ const props: ComponentProps<typeof ChatComposer> = {
+ composerRef: createRef(), capMenuRef: createRef(), capBtnRef: createRef(),
+ spaceMenuRef: createRef(), spaceBtnRef: createRef(), dragCounter: { current: 0 },
+ dragging: false, capMenuOpen: false, spaceMenuOpen: false, hasMessages: true,
+ attachments: [], attachmentError: null,
+ activeCap: { value: "", label: "Chat", description: "Chat", icon: MessageSquare,
+ allowedTools: [] },
+ knowledgeBases: [], llmOptions: [], activeLLMDefault: null, llmSelection: null,
+ llmOptionsLoading: false, llmOptionsError: false,
+ selectedNotebookRecords: [], selectedBookReferences: [], selectedHistorySessions: [],
+ selectedAgentSessions: [], selectedQuestionEntries: [], notebookReferenceGroups: [],
+ selectedPersona: null, selectedMemoryFiles: [], selectedKnowledgeBases: [],
+ isStreaming: false, isVisualizeMode: false, capabilityNeedsConfig: false,
+ capabilityConfigConfirmed: false, onRequestConfigConfirm, capabilities: [],
+ onSetCapMenuOpen: noop, onSetSpaceMenuOpen: noop, onToggleKB: noop,
+ onSelectLLM: noop, onSelectNotebookPicker: noop, onSelectBookPicker: noop,
+ onSelectHistoryPicker: noop, onSelectAgentsPicker: noop, onSelectQuestionBankPicker: noop,
+ onSelectPersonaPicker: noop, onSelectMemoryPicker: noop, onClearPersona: noop,
+ onToggleMemoryFile: noop, onSend, onRemoveAttachment: noop, onRemoveHistory: noop,
+ onRemoveAgent: noop, onRemoveBookReference: noop, onRemoveNotebook: noop,
+ onRemoveQuestion: noop, onDragEnter: noop, onDragLeave: noop, onDragOver: noop,
+ onDrop: noop, onPaste: noop, onAddFiles: noop, onSelectCapability: noop,
+ onCancelStreaming: noop,
+ ...overrides,
+ };
+ render(<ChatComposer {...props} />);
+ const input = screen.getByRole("textbox");
+ fireEvent.change(input, { target: { value: "Explain limits" } });
+ return { input, onSend, onRequestConfigConfirm };
+}
+
+it("opens the required configuration on Enter and preserves the unsent draft", async () => {
+ const { input, onSend, onRequestConfigConfirm } = composer({ capabilityNeedsConfig: true });
+ fireEvent.keyDown(input, { key: "Enter" });
+ await waitFor(() => expect(onRequestConfigConfirm).toHaveBeenCalledOnce());
+ expect(onSend).not.toHaveBeenCalled();
+ expect(input).toHaveValue("Explain limits");
+});
+
+it("sends an answer with Enter while the streaming turn awaits the user", () => {
+ const { input, onSend } = composer({ isStreaming: true, awaitingUserReply: true });
+ fireEvent.keyDown(input, { key: "Enter" });
+ expect(onSend).toHaveBeenCalledExactlyOnceWith("Explain limits");
+ expect(input).toHaveValue("");
+});
+
+it("preserves text while an ordinary turn is streaming", () => {
+ const { input, onSend } = composer({ isStreaming: true });
+ fireEvent.keyDown(input, { key: "Enter" });
+ expect(onSend).not.toHaveBeenCalled();
+ expect(input).toHaveValue("Explain limits");
+});
+
+it("sends confirmed configuration and keeps Shift Enter available", () => {
+ const { input, onSend } = composer({ capabilityNeedsConfig: true, capabilityConfigConfirmed: true });
+ fireEvent.keyDown(input, { key: "Enter", shiftKey: true });
+ expect(onSend).not.toHaveBeenCalled();
+ fireEvent.keyDown(input, { key: "Enter" });
+ expect(onSend).toHaveBeenCalledExactlyOnceWith("Explain limits");
+});