Files
llama.cpp/ui/apps/chat/tests/client/exec-shell-command-streaming.svelte.test.ts
T
Aleksander Grygier 3a7660371d ui: move the web UI to ui/apps/chat and call it Llama Chat (#32032)
* ui: move tools/ui to ui/apps/chat

The chat app moves to its own root folder, ui/apps/chat, as the first step of splitting the UI into one library
(ui/lib) and the apps built on it (ui/apps). The code is unchanged; every path that pointed at tools/ui now points at
ui/apps/chat: CMake adds it from tools/, and the Dockerfiles, the Nix package, the workflows, the labeler, CODEOWNERS,
.editorconfig, the git hooks, the dev and demo scripts and the docs follow it.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: name Llama Chat's package @ggml-org/llama-chat

It was still called llama-ui, the name of the library that now sits beside it
in ui/lib (@ggml-org/llama-ui). The package stays private; the app's display name
and the llama-ui.zip build artifact are unchanged.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: call the built-in web UI Llama Chat in docs, help text and comments

The app in tools/ui is Llama Chat; Llama UI is the component library it is
built from. Prose that said "Web UI", "web UI" or "WebUI" for the app now
names it: the READMEs, SECURITY.md, the --ui help text, the CMake option
description, one server log line, code comments and the Storybook intro.

Names that others depend on are unchanged: the deprecated --webui flag
aliases, the LLAMA_*_WEBUI CMake and environment names, the webui_settings
field, the storage migration keys and the Nix attributes.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: name tools/ui as a former path of Llama Chat in the code-review skill

Changes under the old tools/ui path, as well as tools/server/webui, still
get the Llama Chat checklist.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: name Llama Chat's path in the security policy's exclusions

Llama Chat no longer lives under tools/server/, so the exclusion listed
under it now names ui/apps/chat. What is covered stays the same.

Assisted-by: Claude (Opus 5.5 Medium)
2026-11-16 17:23:36 +01:00

279 lines
8.4 KiB
TypeScript

// Guards the exec_shell_command title while the call is still being
// generated: the command must stream into the terminal title from the
// first character (args arrive as partial JSON), with a blinking cursor
// while the args are incomplete, and the conversation cwd standing in
// for the x-tool-cwd value that only arrives with the result message.
import ChatMessageToolCallBlockExecShellCommand from '$lib/components/app/chat/ChatMessages/ChatMessage/ChatMessageToolCall/ChatMessageToolCallBlockExecShellCommand.svelte';
import ChatMessageAgenticContent from '$lib/components/app/chat/ChatMessages/ChatMessageAgenticContent.svelte';
import { SETTINGS_KEYS } from '$lib/constants';
import { AgenticSectionType, BuiltInTool, MessageRole, MessageType } from '$lib/enums';
import { conversationsStore, settingsStore } from '$lib/stores';
import type { AgenticSection, DatabaseMessage } from '$lib/types';
import { tick } from 'svelte';
import { afterEach, beforeEach, describe, expect, it } from 'vitest';
import { render } from 'vitest-browser-svelte';
const CONV_ID = 'conv-1';
const TOOL_CALL_ID = 'call-1';
const TOOL_NAME = BuiltInTool.SERVER_EXEC_SHELL_COMMAND;
const CWD = '/home/user/project';
function messageWithArgs(args: string): DatabaseMessage {
return {
children: [],
content: '',
convId: CONV_ID,
id: 'assistant-1',
parent: null,
role: MessageRole.ASSISTANT,
timestamp: 0,
toolCalls: JSON.stringify([
{ function: { arguments: args, name: TOOL_NAME }, id: TOOL_CALL_ID }
]),
type: MessageType.TEXT
};
}
function toolResultMessage(content: string, toolCwd?: string): DatabaseMessage {
return {
children: [],
content,
convId: CONV_ID,
id: 'tool-1',
parent: null,
role: MessageRole.TOOL,
timestamp: 0,
toolCallId: TOOL_CALL_ID,
toolCalls: '',
toolCwd,
type: MessageType.TEXT
};
}
function triggerText(container: Element): string {
return container.querySelector('[data-slot="collapsible-trigger"]')?.textContent ?? '';
}
function hasCursor(container: Element): boolean {
return container.querySelector('.exec-cursor') !== null;
}
describe('exec_shell_command streaming title', () => {
beforeEach(() => {
settingsStore.updateMultipleConfig({
[SETTINGS_KEYS.ALWAYS_SHOW_TOOL_CALL_CONTENT]: false,
[SETTINGS_KEYS.SHOW_TOOL_CALL_IN_PROGRESS]: true
});
conversationsStore.activeConversation = {
currNode: null,
cwd: CWD,
id: CONV_ID,
lastModified: 0,
name: 'test'
};
});
afterEach(() => {
conversationsStore.activeConversation = null;
conversationsStore.activeMessages = [];
});
it('streams the partial command into the title with a cursor', async () => {
const { container } = render(ChatMessageAgenticContent, {
isLastAssistantMessage: true,
isStreaming: true,
message: messageWithArgs('{"command":"git sta'),
toolMessages: []
});
await tick();
const title = triggerText(container);
expect(title).toContain('git sta');
expect(title).toContain('$');
expect(title).toContain(CWD);
expect(hasCursor(container)).toBe(true);
});
it('drops the cursor once the args JSON is complete', async () => {
const screen = render(ChatMessageAgenticContent, {
isLastAssistantMessage: true,
isStreaming: true,
message: messageWithArgs('{"command":"git sta'),
toolMessages: []
});
await tick();
expect(hasCursor(screen.container)).toBe(true);
screen.rerender({
isLastAssistantMessage: true,
isStreaming: true,
message: messageWithArgs('{"command":"git status"}'),
toolMessages: []
});
await tick();
expect(triggerText(screen.container)).toContain('git status');
expect(hasCursor(screen.container)).toBe(false);
});
it('switches the prompt from the conversation cwd to the persisted one', async () => {
const screen = render(ChatMessageAgenticContent, {
isLastAssistantMessage: true,
isStreaming: true,
message: messageWithArgs('{"command":"git status"}'),
toolMessages: []
});
await tick();
expect(triggerText(screen.container)).toContain(CWD);
// Result message lands: its x-tool-cwd takes over the prompt.
screen.rerender({
isLastAssistantMessage: true,
isStreaming: true,
message: messageWithArgs('{"command":"git status"}'),
toolMessages: [toolResultMessage('', '/other/dir')]
});
await tick();
expect(triggerText(screen.container)).toContain('/other/dir');
expect(triggerText(screen.container)).not.toContain(CWD);
});
it('shows the executing label only after the command finishes streaming', async () => {
const screen = render(ChatMessageAgenticContent, {
isLastAssistantMessage: true,
isStreaming: true,
message: messageWithArgs('{"command":"git sta'),
toolMessages: []
});
await tick();
// While the args stream, the title cursor alone signals activity.
expect(screen.container.textContent).not.toContain('Executing command...');
screen.rerender({
isLastAssistantMessage: true,
isStreaming: true,
message: messageWithArgs('{"command":"git status"}'),
toolMessages: []
});
await tick();
expect(screen.container.textContent).toContain('Executing command...');
});
it('shows Executing command... while executing before the first output chunk', async () => {
// The result message is created empty right before execution, so
// the block must not go blank while the process produces nothing.
const section: AgenticSection = {
content: '',
toolArgs: '{"command":"sleep 1"}',
toolCallId: TOOL_CALL_ID,
toolName: TOOL_NAME,
toolResult: '',
type: AgenticSectionType.TOOL_CALL
};
const { container } = render(ChatMessageToolCallBlockExecShellCommand, {
isExecuting: true,
isStreaming: true,
open: true,
section
});
await tick();
expect(container.textContent).toContain('Executing command...');
});
it('updates the title when the store mutates toolCalls in place, as the stream does', async () => {
// The live flow never swaps the message object: onToolCallsStreaming
// writes growing toolCalls strings into the same store row per delta.
conversationsStore.activeMessages = [messageWithArgs('')];
const screen = render(ChatMessageAgenticContent, {
isLastAssistantMessage: true,
isStreaming: true,
message: conversationsStore.activeMessages[0]!,
toolMessages: []
});
await tick();
const idx = conversationsStore.findMessageIndex('assistant-1');
for (const args of ['{"command', '{"command":"git', '{"command":"git sta']) {
conversationsStore.updateMessageAtIndex(idx, {
toolCalls: JSON.stringify([
{ function: { arguments: args, name: TOOL_NAME }, id: TOOL_CALL_ID }
])
});
await tick();
expect(triggerText(screen.container)).toContain(args.slice('{"command":"'.length));
expect(hasCursor(screen.container)).toBe(true);
}
});
});
describe('exec_shell_command interrupted call', () => {
beforeEach(() => {
settingsStore.updateMultipleConfig({
[SETTINGS_KEYS.ALWAYS_SHOW_TOOL_CALL_CONTENT]: true,
[SETTINGS_KEYS.SHOW_TOOL_CALL_IN_PROGRESS]: true
});
});
it('marks a call without a result as interrupted once streaming stops', async () => {
const { container } = render(ChatMessageAgenticContent, {
isLastAssistantMessage: true,
isStreaming: false,
message: messageWithArgs('{"command":"git status"}'),
toolMessages: []
});
await tick();
expect(triggerText(container)).toContain('interrupted');
expect(container.textContent).toContain('Command interrupted');
expect(container.textContent).not.toContain('Executing command...');
});
it('marks a command stopped before any output as interrupted', async () => {
// exec_shell_command creates its result message before running, so a
// stop mid-run leaves an empty result rather than none.
const { container } = render(ChatMessageAgenticContent, {
isLastAssistantMessage: true,
isStreaming: false,
message: messageWithArgs('{"command":"sleep 40"}'),
toolMessages: [toolResultMessage('', CWD)]
});
await tick();
expect(triggerText(container)).toContain('interrupted');
expect(container.textContent).toContain('Command interrupted');
});
it('does not keep spinning in an earlier message while a newer reply streams', async () => {
const { container } = render(ChatMessageAgenticContent, {
isLastAssistantMessage: false,
isStreaming: true,
message: messageWithArgs('{"command":"git status"}'),
toolMessages: []
});
await tick();
expect(triggerText(container)).toContain('interrupted');
expect(container.textContent).not.toContain('Executing command...');
});
});