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.

Studio: keep tool cards in place when you edit a reply (#10162)

Nilay2694d7ef8f8b
diff --git a/studio/frontend/src/features/chat/utils/update-thread-message.ts b/studio/frontend/src/features/chat/utils/update-thread-message.ts
index 41109730831..0b6e029b226 100644
--- a/studio/frontend/src/features/chat/utils/update-thread-message.ts
+++ b/studio/frontend/src/features/chat/utils/update-thread-message.ts
@@ -6,70 +6,115 @@ type ThreadImportExport = {
import: (data: ExportedMessageRepository) => void;
};
-type ContentPart = { type: "text" | "reasoning" | "tool"; text: string };
+type ContentPart = { type: "text" | "reasoning" | "tool"; text: string; slot?: number };
+
+// A raw string is prose that extractTaggedText emits as-is, without a marker. It has to
+// count as editable here too, or the restoration list gains a slot the editor never
+// numbered and every marker after it restores the wrong part.
+function isEditablePart(part: any): boolean {
+ return typeof part === 'string' || part?.type === 'text' || part?.type === 'reasoning';
+}
+
+function toolLabel(part: any): string {
+ const name = typeof part?.toolName === 'string' && part.toolName ? part.toolName : part?.type;
+ // The marker is one line delimited by angle brackets, so a label carrying
+ // either would not survive the round trip.
+ const label = typeof name === 'string' ? name.replace(/[<>\n]+/g, ' ').trim() : "";
+ return label || "tool";
+}
+
+// Prose can itself spell a marker -- a reply explaining this very syntax. Escaping it
+// on the way into the editor, and undoing that on the way out, keeps the parser from
+// reading the reply's own words as the card's placeholder. The backslash count carries
+// through, so text that already contains an escaped marker round-trips too.
+function escapeMarkers(text: string): string {
+ return text.replace(/<(\\*)TOOL (\d+: )/g, "<\\$1TOOL $2");
+}
+
+function unescapeMarkers(text: string): string {
+ return text.replace(/<\\(\\*)TOOL (\d+: )/g, "<$1TOOL $2");
+}
/**
- * Extracts only the editable text and reasoning from a message,
- * ignoring structured parts like tool calls that cannot be edited as plain text.
+ * Extracts the editable text and reasoning from a message, with a numbered placeholder
+ * marker recording where each non-editable part sat among the prose.
*/
export function extractTaggedText(content: any): string {
- if (typeof content === 'string') return content;
+ if (typeof content === 'string') return escapeMarkers(content);
if (!Array.isArray(content)) return "";
const open = "\u003C"; // <
const close = "\u003E"; // >
+ let slot = 0;
return content
.map((part: any) => {
- if (typeof part === 'string') return part;
+ if (typeof part === 'string') return escapeMarkers(part);
if (!part) return "";
- // Only extract text from 'text' or 'reasoning' parts.
- // Tool calls/responses are ignored here so they aren't accidentally
- // deleted or corrupted by the user in the textarea.
+ if (!isEditablePart(part)) {
+ slot += 1;
+ return `${open}TOOL ${slot}: ${toolLabel(part)}${close}`;
+ }
+
const text = part.text || part.content || "";
if (!text) return "";
- switch (part.type) {
- case 'reasoning':
- // Trim the text first so we don't accumulate newlines
- // around the tags on every save.
- return `${open}THINK${close}\n${text.trim()}\n${open}/THINK${close}`;
- case 'text':
- default:
- return text;
+ // Trim the text first so we don't accumulate newlines
+ // around the tags on every save.
+ if (part.type === 'reasoning') {
+ return `${open}THINK${close}\n${escapeMarkers(text.trim())}\n${open}/THINK${close}`;
}
+ return escapeMarkers(text);
})
.filter(Boolean)
.join('\n\n');
}
+// extractTaggedText joins parts with a blank line and puts a newline inside the THINK
+// tags. Only that separator may be removed: trimming instead would eat a reply's own
+// leading whitespace, and four spaces are an indented code block, not padding.
+function stripSeparators(text: string, afterTag: boolean, beforeTag: boolean): string {
+ let out = text;
+ if (afterTag) out = out.replace(/^\n\n?/, "");
+ if (beforeTag) out = out.replace(/\n\n?$/, "");
+ return out;
+}
+
function parseTaggedTextToContent(text: string): ContentPart[] {
const parts: ContentPart[] = [];
- const tagRegex = /(<\/?(THINK|TOOL)>)/g;
+ // A tool marker is one whole token carrying its slot number. Requiring the number
+ // keeps a reply that merely writes <TOOL>name</TOOL> in its prose, and a marker the
+ // user half-deleted, from being read as a marker.
+ const tagRegex = /<\/?THINK>|<TOOL (\d+): ([^<>\n]*)>/g;
let lastIndex = 0;
let match;
+ let sawTag = false;
let currentType: ContentPart["type"] = "text";
while ((match = tagRegex.exec(text)) !== null) {
const fullTag = match[0];
- const tagName = match[2];
const index = match.index;
if (index > lastIndex) {
- // Trim the extracted content to remove any leading/trailing
- // newlines created by the tag wrapping process.
- const content = text.substring(lastIndex, index).trim();
- if (content) parts.push({ type: currentType, text: content });
+ const content = stripSeparators(
+ text.substring(lastIndex, index), sawTag, true,
+ );
+ if (content) parts.push({ type: currentType, text: unescapeMarkers(content) });
}
-
- currentType = fullTag.startsWith("</") ? "text" : (tagName === "THINK" ? "reasoning" : "tool");
+ sawTag = true;
lastIndex = index + fullTag.length;
+
+ if (match[1] !== undefined) {
+ parts.push({ type: "tool", text: fullTag, slot: Number(match[1]) });
+ continue;
+ }
+ currentType = fullTag.startsWith("</") ? "text" : "reasoning";
}
if (lastIndex < text.length) {
- const remainingText = text.substring(lastIndex).trim();
- if (remainingText) parts.push({ type: currentType, text: remainingText });
+ const remainingText = stripSeparators(text.substring(lastIndex), sawTag, false);
+ if (remainingText) parts.push({ type: currentType, text: unescapeMarkers(remainingText) });
}
return parts;
@@ -98,27 +143,50 @@ export async function updateThreadMessage(args: {
if (m.message.id !== messageId) return m;
const originalContent = m.message.content;
- let finalContent: any[] = [];
+ const finalContent: any[] = [];
+
+ // Text the editor produced, appended to the run before it rather than opening a
+ // second text part, so a save never multiplies the parts of a reply.
+ const pushText = (text: string) => {
+ const last = finalContent[finalContent.length - 1];
+ if (last && last.type === 'text') {
+ last.text = `${last.text}\n\n${text}`;
+ return;
+ }
+ finalContent.push({ type: 'text', text });
+ };
if (Array.isArray(originalContent)) {
- const firstEditableIndex = originalContent.findIndex((part: any) =>
- part.type === 'text' || part.type === 'reasoning'
+ const nonEditableParts = originalContent.filter(
+ (part: any) => !isEditablePart(part)
);
-
- if (firstEditableIndex === -1) {
- const nonEditableParts = originalContent.filter((part: any) =>
- part.type !== 'text' && part.type !== 'reasoning'
- );
- finalContent = [...parsedEditableContent, ...nonEditableParts];
- } else {
- const before = originalContent.slice(0, firstEditableIndex);
- const after = originalContent.slice(firstEditableIndex + 1).filter((part: any) =>
- part.type !== 'text' && part.type !== 'reasoning'
- );
- finalContent = [...before, ...parsedEditableContent, ...after];
+ const restored = new Set<number>();
+
+ for (const part of parsedEditableContent) {
+ if (part.type !== 'tool') {
+ if (part.type === 'text') pushText(part.text);
+ else finalContent.push(part);
+ continue;
+ }
+ const slot = (part.slot ?? 0) - 1;
+ if (nonEditableParts[slot] && !restored.has(slot)) {
+ restored.add(slot);
+ finalContent.push(nonEditableParts[slot]);
+ } else {
+ // No part of this reply answers to that marker, so it is prose: keep it.
+ pushText(part.text);
+ }
}
+
+ // A card whose marker the user deleted still belongs to the reply.
+ nonEditableParts.forEach((part, i) => {
+ if (!restored.has(i)) finalContent.push(part);
+ });
} else {
- finalContent = parsedEditableContent;
+ for (const part of parsedEditableContent) {
+ if (part.type === 'text' || part.type === 'tool') pushText(part.text);
+ else finalContent.push(part);
+ }
}
return {
diff --git a/studio/frontend/tests/edit-reply-keeps-tool-order.test.ts b/studio/frontend/tests/edit-reply-keeps-tool-order.test.ts
new file mode 100644
index 00000000000..6fb39effcb1
--- /dev/null
+++ b/studio/frontend/tests/edit-reply-keeps-tool-order.test.ts
@@ -0,0 +1,435 @@
+// 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 { loadWithStubs } from "./helpers/module-stubs.ts";
+
+type Exported = {
+ headId: string | null;
+ messages: { parentId: string | null; message: Record<string, unknown> }[];
+};
+
+type Part = Record<string, unknown>;
+
+type Module = {
+ extractTaggedText: (content: unknown) => string;
+ updateThreadMessage: (args: {
+ thread: { export: () => Exported; import: (data: Exported) => void };
+ messageId: string;
+ remoteId: string | undefined;
+ newText: string;
+ isIncognito: boolean;
+ }) => Promise<Part[]>;
+};
+
+const SEARCH: Part = {
+ type: "tool-call",
+ toolCallId: "call-1",
+ toolName: "web_search",
+ args: { query: "unsloth" },
+ result: { ok: true },
+};
+const PYTHON: Part = {
+ type: "tool-call",
+ toolCallId: "call-2",
+ toolName: "python",
+ args: { code: "print(1)" },
+};
+
+function harness() {
+ const saved: Record<string, unknown>[] = [];
+ const module = loadWithStubs<Module>(
+ new URL(
+ "../src/features/chat/utils/update-thread-message.ts",
+ import.meta.url,
+ ),
+ {
+ "../api/chat-api": {
+ saveChatMessage: async (record: Record<string, unknown>) => {
+ saved.push(record);
+ return record;
+ },
+ },
+ },
+ );
+ return { module, saved };
+}
+
+function thread(content: Part[]): Exported {
+ return {
+ headId: "a0",
+ messages: [
+ {
+ parentId: null,
+ message: {
+ id: "u0",
+ role: "user",
+ content: [{ type: "text", text: "search for it" }],
+ createdAt: new Date(1000),
+ },
+ },
+ {
+ parentId: "u0",
+ message: {
+ id: "a0",
+ role: "assistant",
+ content,
+ createdAt: new Date(2000),
+ },
+ },
+ ],
+ };
+}
+
+async function save(content: Part[], newText?: string) {
+ const h = harness();
+ const exported = thread(content);
+ const text = newText ?? h.module.extractTaggedText(content);
+ const result = await h.module.updateThreadMessage({
+ thread: { export: () => exported, import: () => {} },
+ messageId: "a0",
+ remoteId: "remote-1",
+ newText: text,
+ isIncognito: false,
+ });
+ return { result, saved: h.saved[0], text };
+}
+
+test("a no-op Save leaves the tool card between the two sentences", async () => {
+ const content = [
+ { type: "text", text: "Let me look that up." },
+ SEARCH,
+ { type: "text", text: "Here is what I found." },
+ ];
+
+ const { result } = await save(content);
+
+ assert.deepEqual(
+ result.map((part) => part.type),
+ ["text", "tool-call", "text"],
+ );
+ assert.equal(result[0].text, "Let me look that up.");
+ assert.equal(result[1], SEARCH);
+ assert.equal(result[2].text, "Here is what I found.");
+});
+
+test("what is written to the server is what the thread shows", async () => {
+ const content = [
+ { type: "text", text: "Let me look that up." },
+ SEARCH,
+ { type: "text", text: "Here is what I found." },
+ ];
+
+ const { result, saved } = await save(content);
+
+ assert.deepEqual(saved.content, result);
+});
+
+test("several cards keep their order and the prose between them", async () => {
+ const content = [
+ { type: "text", text: "First I search." },
+ SEARCH,
+ { type: "text", text: "Then I compute." },
+ PYTHON,
+ { type: "text", text: "Done." },
+ ];
+
+ const { result } = await save(content);
+
+ assert.deepEqual(
+ result.map((part) => part.type),
+ ["text", "tool-call", "text", "tool-call", "text"],
+ );
+ assert.equal(result[1], SEARCH);
+ assert.equal(result[3], PYTHON);
+});
+
+test("reasoning still round-trips alongside a card", async () => {
+ const content = [
+ { type: "reasoning", text: "The user wants a lookup." },
+ SEARCH,
+ { type: "text", text: "Here is what I found." },
+ ];
+
+ const { result } = await save(content);
+
+ assert.deepEqual(
+ result.map((part) => part.type),
+ ["reasoning", "tool-call", "text"],
+ );
+});
+
+test("an edit that rewrites the prose still keeps the card where it was", async () => {
+ const content = [
+ { type: "text", text: "Let me look that up." },
+ SEARCH,
+ { type: "text", text: "Here is what I found." },
+ ];
+ const { text } = await save(content);
+
+ const { result } = await save(
+ content,
+ text.replace("Here is what I found.", "Rewritten answer."),
+ );
+
+ assert.deepEqual(
+ result.map((part) => part.type),
+ ["text", "tool-call", "text"],
+ );
+ assert.equal(result[2].text, "Rewritten answer.");
+});
+
+test("deleting a marker keeps the call rather than dropping it", async () => {
+ const content = [
+ { type: "text", text: "Let me look that up." },
+ SEARCH,
+ { type: "text", text: "Here is what I found." },
+ ];
+
+ const { result } = await save(
+ content,
+ "Let me look that up.\n\nHere is what I found.",
+ );
+
+ assert.deepEqual(result, [
+ { type: "text", text: "Let me look that up.\n\nHere is what I found." },
+ SEARCH,
+ ]);
+});
+
+test("deleting one marker leaves the other card where its own marker is", async () => {
+ const content = [
+ { type: "text", text: "First I search." },
+ SEARCH,
+ { type: "text", text: "Then I compute." },
+ PYTHON,
+ { type: "text", text: "Done." },
+ ];
+ const shown = await save(content).then((r) => r.text);
+
+ const { result } = await save(
+ content,
+ shown.replace(/<TOOL 1:[^>]*>\n\n/, ""),
+ );
+
+ // The python card is still the one between "Then I compute." and "Done."; only the
+ // card whose marker went away is moved, and it is moved to the end rather than lost.
+ assert.deepEqual(result, [
+ { type: "text", text: "First I search.\n\nThen I compute." },
+ PYTHON,
+ { type: "text", text: "Done." },
+ SEARCH,
+ ]);
+});
+
+test("moving a marker moves that card and no other", async () => {
+ const content = [
+ { type: "text", text: "First I search." },
+ SEARCH,
+ { type: "text", text: "Then I compute." },
+ PYTHON,
+ { type: "text", text: "Done." },
+ ];
+
+ const { result } = await save(
+ content,
+ "First I search.\n\n<TOOL 2: python>\n\nThen I compute.\n\n<TOOL 1: web_search>\n\nDone.",
+ );
+
+ assert.deepEqual(result, [
+ { type: "text", text: "First I search." },
+ PYTHON,
+ { type: "text", text: "Then I compute." },
+ SEARCH,
+ { type: "text", text: "Done." },
+ ]);
+});
+
+test("a half-deleted marker keeps the prose that follows it", async () => {
+ const head = "Here is the plan.";
+ const tail = "I searched and found three papers.";
+ const content = [
+ { type: "text", text: head },
+ SEARCH,
+ { type: "text", text: tail },
+ ];
+ const shown = await save(content).then((r) => r.text);
+ // Whatever the marker looks like, it is what sits between the two sentences.
+ const marker = shown.slice(head.length + 2, shown.length - tail.length - 2);
+
+ // Backspacing into the marker used to turn every following sentence into a part the
+ // save silently dropped, and the loss was written to the server.
+ const broken = [
+ marker.slice(0, -1),
+ marker.slice(1),
+ marker.slice(0, Math.ceil(marker.length / 2)),
+ ];
+ for (const half of broken) {
+ const { result } = await save(content, `${head}\n\n${half}\n\n${tail}`);
+ const text = result
+ .filter((part) => part.type === "text")
+ .map((part) => part.text)
+ .join("\n\n");
+ assert.ok(
+ text.includes(head) && text.includes(tail),
+ `prose lost for ${JSON.stringify(half)}`,
+ );
+ assert.equal(
+ result.filter((part) => part.type === "tool-call").length,
+ 1,
+ `card lost for ${JSON.stringify(half)}`,
+ );
+ }
+});
+
+test("a reply that is only a tool card keeps it", async () => {
+ const { result } = await save([SEARCH]);
+
+ assert.deepEqual(result, [SEARCH]);
+});
+
+function tool(id: string, name = "web_search"): Part {
+ return { type: "tool-call", toolCallId: id, toolName: name, args: {}, result: {} };
+}
+
+async function roundTrip(content: Part[]): Promise<Part[]> {
+ const { result } = await save(content);
+ return result;
+}
+
+const shapes: any[][] = [
+ [{ type: "text", text: "A" }, tool("1"), { type: "text", text: "B" }],
+ [tool("1"), { type: "text", text: "A" }],
+ [{ type: "text", text: "A" }, tool("1")],
+ [tool("1"), tool("2")],
+ [{ type: "text", text: "A" }, tool("1"), { type: "text", text: "B" }, tool("2"),
+ { type: "text", text: "C" }],
+ [{ type: "reasoning", text: "R" }, tool("1"), { type: "text", text: "A" }],
+ [{ type: "text", text: "A" }, { type: "source", title: "S", url: "u" },
+ { type: "text", text: "B" }],
+ [{ type: "text", text: "A" }, tool("1"), tool("2"), { type: "text", text: "B" }],
+ [{ type: "reasoning", text: "R" }],
+ [tool("1")],
+];
+
+test("a no-op save preserves the part sequence for every shape", async () => {
+ for (const shape of shapes) {
+ const out = await roundTrip(shape);
+ assert.deepEqual(out.map((p: any) => p.type), shape.map((p: any) => p.type),
+ `shape ${JSON.stringify(shape.map((p: any) => p.type))}`);
+ assert.deepEqual(
+ out.filter((p: any) => p.type === "tool-call").map((p: any) => p.toolCallId),
+ shape.filter((p: any) => p.type === "tool-call").map((p: any) => p.toolCallId));
+ }
+});
+
+test("a second no-op save changes nothing further (idempotent)", async () => {
+ for (const shape of shapes) {
+ const once = await roundTrip(shape);
+ const twice = await roundTrip(once);
+ assert.deepEqual(twice.map((p: any) => p.type), once.map((p: any) => p.type));
+ }
+});
+
+test("prose that mentions the marker tag is not mistaken for one", async () => {
+ const content = [
+ { type: "text", text: "Write <TOOL>web_search</TOOL> to call it." },
+ tool("1"),
+ { type: "text", text: "Done." },
+ ];
+ const out = await roundTrip(content);
+ // Not just the count: the sentence has to come back whole, with the card still
+ // between it and "Done." rather than wedged into the middle of it.
+ assert.deepEqual(out, content);
+});
+
+test("prose that spells a real marker is not mistaken for that card's marker", async () => {
+ // A reply explaining the marker syntax, that itself used the tool it names: the
+ // literal occurrence sits BEFORE the card's own marker and reads exactly like it.
+ const content = [
+ { type: "text", text: "Your edit box shows <TOOL 1: web_search> where the card sits." },
+ SEARCH,
+ { type: "text", text: "That is all it means." },
+ ];
+
+ assert.deepEqual(await roundTrip(content), content);
+});
+
+test("text that already contains an escaped marker round-trips too", async () => {
+ const content = [
+ { type: "text", text: "Write <\\TOOL 1: web_search> to show the escape." },
+ SEARCH,
+ { type: "text", text: "Done." },
+ ];
+
+ assert.deepEqual(await roundTrip(content), content);
+});
+
+test("an indented code block after a card keeps its indentation", async () => {
+ // Four leading spaces are a Markdown code block, not padding: trimming them at the
+ // marker boundary would render the reply differently after a no-op Save.
+ const content = [
+ { type: "text", text: "Here is the fix:" },
+ SEARCH,
+ { type: "text", text: " const x = 1;\n return x;" },
+ ];
+
+ assert.deepEqual(await roundTrip(content), content);
+});
+
+test("a raw string part is prose, and does not consume a card's slot", async () => {
+ // Legacy and imported rows can hold a bare string. extractTaggedText emits it as
+ // prose without numbering it, so restoration must not count it as a card either.
+ const legacy = ["intro", SEARCH, { type: "text", text: "answer" }] as unknown as Part[];
+ const { result } = await save(legacy);
+
+ assert.deepEqual(result, [
+ { type: "text", text: "intro" },
+ SEARCH,
+ { type: "text", text: "answer" },
+ ]);
+});
+
+test("a reply stored as one plain string round-trips, markers and all", async () => {
+ // Legacy and imported rows can hold the whole reply as a top-level string, which
+ // takes its own path out of extractTaggedText and has to be escaped there too.
+ const content = "Use <TOOL 1: web_search> literally" as unknown as Part[];
+
+ const { result } = await save(content);
+
+ assert.deepEqual(result, [
+ { type: "text", text: "Use <TOOL 1: web_search> literally" },
+ ]);
+});
+
+test("a code block quoting the marker syntax survives a no-op save", async () => {
+ const content = [
+ { type: "text", text: "```xml\n<TOOL>read_file</TOOL>\n```" },
+ tool("1"),
+ { type: "text", text: "Done." },
+ ];
+
+ assert.deepEqual(await roundTrip(content), content);
+});
+
+test("a no-op save returns the very same text, part for part", async () => {
+ for (const shape of shapes) {
+ assert.deepEqual(await roundTrip(shape), shape,
+ `shape ${JSON.stringify(shape.map((p: any) => p.type))}`);
+ }
+});
+
+test("no tool part is ever dropped, whatever the edit", async () => {
+ for (const shape of shapes) {
+ const { result } = await save(shape, "the user deleted everything");
+ const before = shape.filter((p) => p.type !== "text" && p.type !== "reasoning");
+ const after = result.filter((p) => p.type !== "text" && p.type !== "reasoning");
+ assert.equal(
+ after.length,
+ before.length,
+ `non-text parts lost for ${JSON.stringify(shape.map((p) => p.type))}`,
+ );
+ }
+});