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.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
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.tsxindex 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() {<Inputvalue={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.tsxindex 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><Inputvalue={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.tsindex 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.tsnew file mode 100644index 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);+ }+});