Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

fix(studio): prevent IME confirmation from submitting chat renames (#12613)

Daniel Hanbe2f942a9963
diff --git a/studio/frontend/src/components/app-sidebar.tsx b/studio/frontend/src/components/app-sidebar.tsx
index de782d25efc..cbedcd7eb6a 100644
--- a/studio/frontend/src/components/app-sidebar.tsx
+++ b/studio/frontend/src/components/app-sidebar.tsx
@@ -209,6 +209,12 @@ import {
sectionKeyLanding,
useSectionDrag,
} from "@/features/chat";
+import {
+ imeOwnsInputKeydown,
+ inputImeHandlers,
+ newInputImeState,
+ resetInputIme,
+} from "@/features/chat/utils/composer-preferences";
import { sandboxSessionIdFor } from "@/components/assistant-ui/sandbox-files";
import { NewProjectDialog } from "@/features/chat/components/new-project-dialog";
import {
@@ -2868,6 +2874,7 @@ export function AppSidebar() {
const [renameDraft, setRenameDraft] = useState("");
// Skips the inline rename input's blur-commit when Enter/Escape already handled it.
const skipRenameBlurRef = useRef(false);
+ const renameImeRef = useRef(newInputImeState());
// Optimistic title while the debounced sidebar refresh catches up, so the old name doesn't flash.
const [pendingRename, setPendingRename] = useState<{
id: string;
@@ -2953,6 +2960,8 @@ export function AppSidebar() {
function handleInlineRenameKeyDown(
event: React.KeyboardEvent<HTMLInputElement>,
) {
+ // IME Enter/Escape must not finish the rename; check before preventDefault.
+ if (imeOwnsInputKeydown(event, renameImeRef.current)) return;
if (event.key === "Enter") {
event.preventDefault();
skipRenameBlurRef.current = true;
@@ -4514,8 +4523,15 @@ export function AppSidebar() {
value={renameDraft}
onChange={(event) => setRenameDraft(event.target.value)}
onKeyDown={handleInlineRenameKeyDown}
- onBlur={handleInlineRenameBlur}
- onFocus={(event) => event.currentTarget.select()}
+ {...inputImeHandlers(renameImeRef.current)}
+ onBlur={() => {
+ resetInputIme(renameImeRef.current);
+ handleInlineRenameBlur();
+ }}
+ onFocus={(event) => {
+ resetInputIme(renameImeRef.current);
+ event.currentTarget.select();
+ }}
maxLength={120}
aria-label={translate("shell.dialog.renameChat.placeholder")}
className={cn(
@@ -5959,7 +5975,13 @@ export function AppSidebar() {
if (!open) setRenamingTarget(null);
}}
>
- <DialogContent className="corner-squircle dialog-soft-surface sm:max-w-md">
+ <DialogContent
+ className="corner-squircle dialog-soft-surface sm:max-w-md"
+ // Radix handles Escape before the input; don't close on IME dismissal.
+ onEscapeKeyDown={(event) => {
+ if (event.isComposing || event.keyCode === 229) event.preventDefault();
+ }}
+ >
<DialogHeader>
<DialogTitle>
{renamingTarget?.kind === "run"
@@ -5970,7 +5992,9 @@ export function AppSidebar() {
<Input
value={renameDraft}
onChange={(event) => setRenameDraft(event.target.value)}
+ {...inputImeHandlers(renameImeRef.current)}
onKeyDown={(event) => {
+ if (imeOwnsInputKeydown(event, renameImeRef.current)) return;
if (event.key === "Enter") {
event.preventDefault();
void commitRename();
diff --git a/studio/frontend/src/features/chat/thread-sidebar.tsx b/studio/frontend/src/features/chat/thread-sidebar.tsx
index 73a46f83940..2b70ce04cc1 100644
--- a/studio/frontend/src/features/chat/thread-sidebar.tsx
+++ b/studio/frontend/src/features/chat/thread-sidebar.tsx
@@ -1,7 +1,12 @@
// SPDX-License-Identifier: AGPL-3.0-only
// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
-import { useState } from "react";
+import { useRef, useState } from "react";
+import {
+ imeOwnsInputKeydown,
+ inputImeHandlers,
+ newInputImeState,
+} from "@/features/chat/utils/composer-preferences";
import {
SidebarContent,
SidebarFooter,
@@ -107,6 +112,7 @@ export function ThreadSidebar({
const [renamingItem, setRenamingItem] = useState<SidebarItem | null>(null);
const [renameDraft, setRenameDraft] = useState("");
+ const renameImeRef = useRef(newInputImeState());
function viewForItem(item: SidebarItem): ChatView {
return item.type === "single"
@@ -352,14 +358,21 @@ export function ThreadSidebar({
{/* Rename dialog */}
<Dialog open={renamingItem !== null} onOpenChange={(open) => { if (!open) setRenamingItem(null); }}>
- <DialogContent className="corner-squircle dialog-soft-surface sm:max-w-sm">
+ <DialogContent
+ className="corner-squircle dialog-soft-surface sm:max-w-sm"
+ onEscapeKeyDown={(e) => { if (e.isComposing || e.keyCode === 229) e.preventDefault(); }}
+ >
<DialogHeader>
<DialogTitle>Rename chat</DialogTitle>
</DialogHeader>
<Input
value={renameDraft}
onChange={(e) => setRenameDraft(e.target.value)}
- onKeyDown={(e) => { if (e.key === "Enter") void commitRename(); }}
+ {...inputImeHandlers(renameImeRef.current)}
+ onKeyDown={(e) => {
+ if (imeOwnsInputKeydown(e, renameImeRef.current)) return;
+ if (e.key === "Enter") void commitRename();
+ }}
autoFocus
/>
<DialogFooter>
diff --git a/studio/frontend/src/features/chat/utils/composer-preferences.ts b/studio/frontend/src/features/chat/utils/composer-preferences.ts
index f6f66093567..b69a66883ca 100644
--- a/studio/frontend/src/features/chat/utils/composer-preferences.ts
+++ b/studio/frontend/src/features/chat/utils/composer-preferences.ts
@@ -35,6 +35,53 @@ export function imeKeydownBlocksComposerSubmit(
);
}
+export type InputImeState = { open: boolean; endedAt: number };
+
+export function newInputImeState(): InputImeState {
+ return { open: false, endedAt: -Infinity };
+}
+
+export function resetInputIme(ime: InputImeState) {
+ ime.open = false;
+ ime.endedAt = -Infinity;
+}
+
+export function inputImeHandlers(ime: InputImeState) {
+ // compositionend can go missing (#5546); a focus change always ends the composition.
+ const reset = () => resetInputIme(ime);
+ return {
+ onFocus: reset,
+ onBlur: reset,
+ onCompositionStart: () => {
+ ime.open = true;
+ },
+ onCompositionEnd: (event: { timeStamp: number }) => {
+ ime.open = false;
+ ime.endedAt = event.timeStamp;
+ },
+ };
+}
+
+/** True when the keydown belongs to an IME; idle macOS Pinyin Enter (229, #12137) passes. */
+export function imeOwnsInputKeydown(
+ event: ComposerKeyEvent & {
+ timeStamp: number;
+ nativeEvent: { isComposing?: boolean };
+ },
+ ime: InputImeState,
+): boolean {
+ const msSinceCompositionEnd = event.timeStamp - ime.endedAt;
+ ime.endedAt = -Infinity;
+ if (event.nativeEvent.isComposing) return true;
+ if (event.keyCode !== 229) {
+ // Candidate-confirming Enter can arrive as keyCode 13 mid-composition; swallow it once.
+ const confirmsCandidate = ime.open && event.key === "Enter";
+ ime.open = false;
+ return confirmsCandidate;
+ }
+ return imeKeydownBlocksComposerSubmit(event, ime.open, msSinceCompositionEnd);
+}
+
export function composerKeyEventForImeSubmit(
event: ComposerKeyEvent,
): ComposerKeyEvent {
diff --git a/studio/frontend/tests/chat-rename-ime.test.ts b/studio/frontend/tests/chat-rename-ime.test.ts
new file mode 100644
index 00000000000..90ce6918a0b
--- /dev/null
+++ b/studio/frontend/tests/chat-rename-ime.test.ts
@@ -0,0 +1,298 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0
+
+import assert from "node:assert/strict";
+import test from "node:test";
+import ts from "typescript";
+import { readSrc } from "./helpers/kit.ts";
+import {
+ imeOwnsInputKeydown,
+ inputImeHandlers,
+ newInputImeState,
+} from "../src/features/chat/utils/composer-preferences.ts";
+
+// Runs the shipped callbacks to catch guards placed after preventDefault or side effects.
+function handler(
+ file: string,
+ inline: boolean | "escape",
+ deps: Record<string, unknown>,
+) {
+ const source = ts.createSourceFile(
+ file,
+ readSrc(file),
+ ts.ScriptTarget.Latest,
+ true,
+ ts.ScriptKind.TSX,
+ );
+ const matches: ts.Node[] = [];
+ function visit(node: ts.Node) {
+ if (inline === "escape") {
+ if (
+ ts.isJsxAttribute(node) &&
+ node.name.getText(source) === "onEscapeKeyDown" &&
+ node.initializer &&
+ ts.isJsxExpression(node.initializer) &&
+ node.initializer.expression &&
+ ts.isArrowFunction(node.initializer.expression) &&
+ node.parent.parent.parent.getText(source).includes("commitRename()")
+ )
+ matches.push(node.initializer.expression);
+ } else if (inline) {
+ if (
+ ts.isFunctionDeclaration(node) &&
+ node.name?.text === "handleInlineRenameKeyDown"
+ )
+ matches.push(node);
+ } else if (
+ ts.isJsxAttribute(node) &&
+ node.name.getText(source) === "onKeyDown" &&
+ node.initializer &&
+ ts.isJsxExpression(node.initializer) &&
+ node.initializer.expression &&
+ ts.isArrowFunction(node.initializer.expression) &&
+ node.initializer.expression.getText(source).includes("commitRename()")
+ )
+ matches.push(node.initializer.expression);
+ ts.forEachChild(node, visit);
+ }
+ visit(source);
+ assert.equal(
+ matches.length,
+ 1,
+ `${file}: unique ${inline === "escape" ? "dialog Escape" : "rename"} handler`,
+ );
+ const code = ts.transpileModule(`return (${matches[0].getText(source)});`, {
+ compilerOptions: {
+ target: ts.ScriptTarget.ES2022,
+ module: ts.ModuleKind.None,
+ },
+ }).outputText;
+ return new Function(...Object.keys(deps), code)(...Object.values(deps)) as (
+ event: object,
+ ) => void;
+}
+
+function fixture(file: string, inline: boolean, dirty = true) {
+ const effects: string[] = [];
+ const skipRenameBlurRef = { current: false };
+ const renameImeRef = { current: newInputImeState() };
+ const ime = inputImeHandlers(renameImeRef.current);
+ let now = 1000;
+ const onKey = handler(file, inline, {
+ imeOwnsInputKeydown,
+ renameImeRef,
+ renameDirty: dirty,
+ skipRenameBlurRef,
+ commitRename: () => effects.push("save"),
+ setRenamingTarget: () => effects.push("close"),
+ });
+ function key(
+ key: string,
+ isComposing = false,
+ keyCode = key === "Enter" ? 13 : 27,
+ ) {
+ now += 1000;
+ onKey({
+ key,
+ keyCode,
+ metaKey: false,
+ ctrlKey: false,
+ shiftKey: false,
+ altKey: false,
+ timeStamp: now,
+ nativeEvent: { isComposing, keyCode },
+ preventDefault: () => effects.push("prevent"),
+ });
+ }
+ // WebKit order (bug 165004): compositionend lands just before the committing 229 keydown.
+ function compose(start: boolean) {
+ if (start) ime.onCompositionStart();
+ else ime.onCompositionEnd({ timeStamp: now + 999 });
+ }
+ return { effects, skipRenameBlurRef, key, compose };
+}
+
+for (const [name, file, inline] of [
+ ["sidebar inline", "components/app-sidebar.tsx", true],
+ ["sidebar dialog", "components/app-sidebar.tsx", false],
+ ["thread sidebar dialog", "features/chat/thread-sidebar.tsx", false],
+] as const) {
+ for (const [isComposing, keyCode] of [
+ [true, 13],
+ [false, 229],
+ [true, 229],
+ ] as const) {
+ test(`${name}: IME Enter (${isComposing}, ${keyCode}) keeps editing until a separate Enter`, () => {
+ const f = fixture(file, inline);
+ f.compose(true);
+ if (!isComposing) f.compose(false);
+ f.key("Enter", isComposing, keyCode);
+ assert.deepEqual(f.effects, []);
+ assert.equal(f.skipRenameBlurRef.current, false);
+ // Chrome/Firefox order: compositionend follows the composing keydown.
+ if (isComposing) f.compose(false);
+ f.key("Enter");
+ assert.equal(f.effects.filter((effect) => effect === "save").length, 1);
+ if (inline) assert.equal(f.skipRenameBlurRef.current, true);
+ });
+ }
+}
+
+for (const dirty of [true, false]) {
+ test(`sidebar inline: candidate Escape preserves editing (dirty=${dirty})`, () => {
+ const f = fixture("components/app-sidebar.tsx", true, dirty);
+ f.key("Escape", true);
+ f.key("Escape", false, 229);
+ assert.deepEqual(f.effects, []);
+ assert.equal(f.skipRenameBlurRef.current, false);
+ f.key("Escape");
+ assert.deepEqual(f.effects, ["prevent", "close"]);
+ assert.equal(f.skipRenameBlurRef.current, true);
+ });
+}
+
+for (const [name, file, inline] of [
+ ["sidebar inline", "components/app-sidebar.tsx", true],
+ ["sidebar dialog", "components/app-sidebar.tsx", false],
+ ["thread sidebar dialog", "features/chat/thread-sidebar.tsx", false],
+] as const) {
+ test(`${name}: idle macOS Pinyin Enter (229, no composition) saves (#12137)`, () => {
+ const f = fixture(file, inline);
+ f.key("Enter", false, 229);
+ assert.equal(f.effects.filter((effect) => effect === "save").length, 1);
+ });
+
+ test(`${name}: open composition keeps a 229 Enter blocked`, () => {
+ const f = fixture(file, inline);
+ f.compose(true);
+ f.key("Enter", false, 229);
+ assert.deepEqual(f.effects, []);
+ });
+}
+
+test("sidebar inline: an unchanged IME Enter does not close the input", () => {
+ const f = fixture("components/app-sidebar.tsx", true, false);
+ f.compose(true);
+ f.key("Enter", true);
+ f.compose(false);
+ f.key("Enter", false, 229);
+ assert.deepEqual(f.effects, []);
+ f.key("Enter");
+ assert.deepEqual(f.effects, ["prevent", "close"]);
+});
+
+for (const [name, file] of [
+ ["sidebar dialog", "components/app-sidebar.tsx"],
+ ["thread sidebar dialog", "features/chat/thread-sidebar.tsx"],
+] as const) {
+ test(`${name}: candidate Escape does not close the dialog`, () => {
+ // Radix fires this before the input's onKeyDown, so the input guard alone is not enough.
+ const onEscape = handler(file, "escape", {});
+ const press = (isComposing: boolean, keyCode: number) => {
+ let prevented = false;
+ onEscape({
+ key: "Escape",
+ isComposing,
+ keyCode,
+ preventDefault: () => (prevented = true),
+ });
+ return prevented;
+ };
+ assert.equal(press(true, 27), true);
+ assert.equal(press(false, 229), true);
+ assert.equal(press(false, 27), false);
+ });
+}
+
+// A lost compositionend (#5546, macOS input-method switch) must not pin later idle Pinyin Enters.
+for (const reset of ["onFocus", "onBlur"] as const) {
+ test(`missing compositionend is cleared by ${reset}`, () => {
+ const state = newInputImeState();
+ const ime = inputImeHandlers(state);
+ ime.onCompositionStart();
+ assert.equal(state.open, true);
+ ime[reset]();
+ const enter = {
+ key: "Enter",
+ keyCode: 229,
+ metaKey: false,
+ ctrlKey: false,
+ shiftKey: false,
+ altKey: false,
+ timeStamp: 5000,
+ nativeEvent: { isComposing: false },
+ };
+ assert.equal(imeOwnsInputKeydown(enter, state), false);
+ });
+}
+
+const plainEnter = (keyCode: number, timeStamp: number) => ({
+ key: "Enter",
+ keyCode,
+ metaKey: false,
+ ctrlKey: false,
+ shiftKey: false,
+ altKey: false,
+ timeStamp,
+ nativeEvent: { isComposing: false },
+});
+
+test("focus change clears a recent compositionend so the next idle Pinyin Enter saves", () => {
+ const state = newInputImeState();
+ const ime = inputImeHandlers(state);
+ ime.onCompositionStart();
+ ime.onCompositionEnd({ timeStamp: 1000 });
+ ime.onBlur();
+ ime.onFocus();
+ assert.equal(imeOwnsInputKeydown(plainEnter(229, 1100), state), false);
+});
+
+test("a keyCode 13 candidate-confirming Enter inside an open composition is swallowed once", () => {
+ const state = newInputImeState();
+ inputImeHandlers(state).onCompositionStart();
+ assert.equal(imeOwnsInputKeydown(plainEnter(13, 2000), state), true);
+ assert.equal(imeOwnsInputKeydown(plainEnter(13, 5000), state), false);
+});
+
+test("every rename input resets IME state on focus and blur", () => {
+ for (const file of [
+ "components/app-sidebar.tsx",
+ "features/chat/thread-sidebar.tsx",
+ ]) {
+ const source = ts.createSourceFile(
+ file,
+ readSrc(file),
+ ts.ScriptTarget.Latest,
+ true,
+ ts.ScriptKind.TSX,
+ );
+ function visit(node: ts.Node) {
+ if (ts.isJsxAttributes(node)) {
+ const props = node.properties;
+ const spread = props.findIndex(
+ (p) =>
+ ts.isJsxSpreadAttribute(p) &&
+ p.expression.getText(source).startsWith("inputImeHandlers("),
+ );
+ if (spread >= 0) {
+ for (const name of ["onFocus", "onBlur"]) {
+ const override = props.findIndex(
+ (p, i) =>
+ i > spread &&
+ ts.isJsxAttribute(p) &&
+ p.name.getText(source) === name,
+ );
+ if (override >= 0)
+ assert.match(
+ props[override].getText(source),
+ /resetInputIme\(renameImeRef\.current\)/,
+ `${file}: ${name} override drops the IME reset`,
+ );
+ }
+ }
+ }
+ ts.forEachChild(node, visit);
+ }
+ visit(source);
+ }
+});