Files
llama.cpp/ui/apps/chat/tests/unit/agentic-sections.test.ts
T
Aleksander Grygier 67cf8967eb ui: move Llama Chat to SvelteKit 3 and its built-in service worker (#32463)
* ui: replace deprecated packages and fix npm audit findings

Swap the mdast stub for @types/mdast, move the katex override to 0.19.0,
and override glob, source-map and html-encoding-sniffer under
workbox-build and http-server so installs no longer pull deprecated
packages. Apply the non-breaking npm audit fixes to the lockfile.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: migrate Llama Chat to SvelteKit 3 and its built-in service worker

Move to SvelteKit 3, Vite 8, TypeScript 6 and Storybook 10.6. The
SvelteKit options move from svelte.config.js into sveltekit() in
vite.config.ts, $lib imports become #lib subpath imports from
package.json, and $app/environment becomes $app/env. Modules named
server.* or living under a server/ folder are server-only in SvelteKit 3,
so the llama-server components, store and enums move to llama-server
names.

@vite-pwa/sveltekit and Workbox give way to SvelteKit's own service
worker in src/service-worker, registered by usePwa(), which precaches the
app files and leaves API requests to the network. A small plugin emits
manifest.webmanifest. static/sw.js removes the worker of older builds, and
llama-server serves a self-removing service-worker.js as well as sw.js
when the built-in UI is off or replaced.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: use SvelteKit 3's update detection and Svelte 5's current patterns

A page the service worker doesn't control now learns of a new build
from SvelteKit itself: `updated` from $app/state checks
_app/version.json on navigation, on focus and every hour. It replaces
the version Llama Chat kept in localStorage and compared by hand.
Reload on the update prompt pulls in the new worker and activates it
before reloading, so one click lands on the new build, whether or not
a worker controlled the page.

Following Svelte's current guidance:
- usePwa keeps its state in $state rather than a store, and no effect
  checks `browser`
- nearViewport, autoResizeTextarea and the custom CSS injection are
  attachments ({@attach}) rather than actions (use:)
- class lists use arrays rather than class: directives
- the chat contexts come from createContext, typed, in place of
  setContext/getContext with string keys
- ActionIconCopyToClipboard takes $props() rather than `export let`

Assisted-by: Claude (Opus 5.5 Medium)

* ui: move to ESLint 10

ESLint 9 is out of support. Every plugin the app uses supports 10:
typescript-eslint, eslint-plugin-svelte, perfectionist,
simple-import-sort, eslint-plugin-storybook and eslint-config-prettier.
@eslint/js and @eslint/compat follow.

ESLint 10's recommended rules ask for two things the code now does:
errors rethrown from a catch keep the caught error as their `cause`,
and no variable starts with a value that every path overwrites.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: override minimatch to clear npm audit's last finding

ESLint 10.14, @eslint/config-array 0.23.5 and typescript-eslint 8.72
depend on minimatch 10, which GHSA-g3hv-75wg-m249 (denial of service
via globparts amplification) affects below 11.0.1. Their fixed releases
move to minimatch 11 but are all younger than the repo's 7-day
min-release-age, so an override pins minimatch 11.0.5, the newest the
rule allows. The three only call new Minimatch(), match() and
minimatch(), which minimatch 11 keeps. npm audit now finds nothing.

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

404 lines
14 KiB
TypeScript

import { AgenticSectionType, MessageRole } from '#lib/enums/index.ts';
import type { ApiChatCompletionToolCall } from '#lib/types/api.js';
import type { DatabaseMessage } from '#lib/types/database.js';
import { deriveAgenticSections, hasAgenticContent } from '#lib/utils/agentic.ts';
import { describe, expect, it } from 'vitest';
function makeAssistant(overrides: Partial<DatabaseMessage> = {}): DatabaseMessage {
return {
children: [],
content: overrides.content ?? '',
convId: 'conv-1',
id: overrides.id ?? 'ast-1',
parent: null,
role: MessageRole.ASSISTANT,
timestamp: Date.now(),
type: 'text',
...overrides
} as DatabaseMessage;
}
function makeToolMsg(overrides: Partial<DatabaseMessage> = {}): DatabaseMessage {
return {
children: [],
content: overrides.content ?? 'tool result',
convId: 'conv-1',
id: overrides.id ?? 'tool-1',
parent: null,
role: MessageRole.TOOL,
timestamp: Date.now(),
toolCallId: overrides.toolCallId ?? 'call_1',
type: 'text',
...overrides
} as DatabaseMessage;
}
describe('deriveAgenticSections', () => {
it('returns empty array for assistant with no content', () => {
const msg = makeAssistant({ content: '' });
const sections = deriveAgenticSections(msg);
expect(sections).toEqual([]);
});
it('returns text section for simple assistant message', () => {
const msg = makeAssistant({ content: 'Hello world' });
const sections = deriveAgenticSections(msg);
expect(sections).toHaveLength(1);
expect(sections[0].type).toBe(AgenticSectionType.TEXT);
expect(sections[0].content).toBe('Hello world');
});
it('returns reasoning + text for message with reasoning', () => {
const msg = makeAssistant({
content: 'Answer is 4.',
reasoningContent: 'Let me think...'
});
const sections = deriveAgenticSections(msg);
expect(sections).toHaveLength(2);
expect(sections[0].type).toBe(AgenticSectionType.REASONING);
expect(sections[0].content).toBe('Let me think...');
expect(sections[1].type).toBe(AgenticSectionType.TEXT);
});
it('single turn: assistant with tool calls and results', () => {
const msg = makeAssistant({
content: 'Let me check.',
toolCalls: JSON.stringify([
{
function: { arguments: '{"q":"test"}', name: 'search' },
id: 'call_1',
type: 'function'
}
])
});
const toolResult = makeToolMsg({
content: 'Found 3 results',
toolCallId: 'call_1'
});
const sections = deriveAgenticSections(msg, [toolResult]);
expect(sections).toHaveLength(2);
expect(sections[0].type).toBe(AgenticSectionType.TEXT);
expect(sections[1].type).toBe(AgenticSectionType.TOOL_CALL);
expect(sections[1].toolName).toBe('search');
expect(sections[1].toolResult).toBe('Found 3 results');
});
it('single turn: pending tool call without result', () => {
const msg = makeAssistant({
toolCalls: JSON.stringify([
{ function: { arguments: '{}', name: 'bash' }, id: 'call_1', type: 'function' }
])
});
const sections = deriveAgenticSections(msg, [], [], true);
expect(sections).toHaveLength(1);
expect(sections[0].type).toBe(AgenticSectionType.TOOL_CALL_PENDING);
expect(sections[0].toolName).toBe('bash');
});
it('chat-streaming write_file surfaces as TOOL_CALL_PENDING with partial toolArgs (not TOOL_CALL_STREAMING)', () => {
// Regression: while the LLM is emitting a write_file tool call's
// args, `chat.svelte.ts` JSON-encodes the partial tool-call array on
// every chunk, so `parseToolCalls` succeeds and the section is
// classified TOOL_CALL_PENDING - not TOOL_CALL_STREAMING (which is
// only produced from the `streamingToolCalls` parameter, never set
// by current UI callers). Streaming-only UI like auto-scroll in the
// code block must still trigger, driven by `isStreaming && (isPending
// || isStreamingCall)`, not `isStreamingCall` alone.
const partialArgs = '{"path":"/Users/fifa2026.html","content":"<!DOCTYPE h';
const msg = makeAssistant({
toolCalls: JSON.stringify([
{ function: { arguments: partialArgs, name: 'write_file' }, id: 'call_1', type: 'function' }
])
});
const sections = deriveAgenticSections(msg, [], [], true);
expect(sections).toHaveLength(1);
expect(sections[0].type).toBe(AgenticSectionType.TOOL_CALL_PENDING);
expect(sections[0].type).not.toBe(AgenticSectionType.TOOL_CALL_STREAMING);
expect(sections[0].toolName).toBe('write_file');
expect(sections[0].toolArgs).toBe(partialArgs);
});
it('multi-turn: two assistant turns grouped as one session', () => {
const assistant1 = makeAssistant({
content: 'Turn 1 text',
id: 'ast-1',
toolCalls: JSON.stringify([
{
function: { arguments: '{"q":"foo"}', name: 'search' },
id: 'call_1',
type: 'function'
}
])
});
const tool1 = makeToolMsg({ content: 'result 1', id: 'tool-1', toolCallId: 'call_1' });
const assistant2 = makeAssistant({
content: 'Final answer based on results.',
id: 'ast-2'
});
// toolMessages contains both tool result and continuation assistant
const sections = deriveAgenticSections(assistant1, [tool1, assistant2]);
expect(sections).toHaveLength(3);
// Turn 1
expect(sections[0].type).toBe(AgenticSectionType.TEXT);
expect(sections[0].content).toBe('Turn 1 text');
expect(sections[1].type).toBe(AgenticSectionType.TOOL_CALL);
expect(sections[1].toolName).toBe('search');
expect(sections[1].toolResult).toBe('result 1');
// Turn 2 (final)
expect(sections[2].type).toBe(AgenticSectionType.TEXT);
expect(sections[2].content).toBe('Final answer based on results.');
});
it('multi-turn: three turns with tool calls', () => {
const assistant1 = makeAssistant({
content: '',
id: 'ast-1',
toolCalls: JSON.stringify([
{
function: { arguments: '{}', name: 'list_files' },
id: 'call_1',
type: 'function'
}
])
});
const tool1 = makeToolMsg({ content: 'file1 file2', id: 'tool-1', toolCallId: 'call_1' });
const assistant2 = makeAssistant({
content: 'Reading file1...',
id: 'ast-2',
toolCalls: JSON.stringify([
{
function: { arguments: '{"path":"file1"}', name: 'read_file' },
id: 'call_2',
type: 'function'
}
])
});
const tool2 = makeToolMsg({
content: 'contents of file1',
id: 'tool-2',
toolCallId: 'call_2'
});
const assistant3 = makeAssistant({
content: 'Here is the analysis.',
id: 'ast-3',
reasoningContent: 'The file contains...'
});
const sections = deriveAgenticSections(assistant1, [tool1, assistant2, tool2, assistant3]);
// Turn 1: tool_call (no text since content is empty)
// Turn 2: text + tool_call
// Turn 3: reasoning + text
expect(sections).toHaveLength(5);
expect(sections[0].type).toBe(AgenticSectionType.TOOL_CALL);
expect(sections[0].toolName).toBe('list_files');
expect(sections[1].type).toBe(AgenticSectionType.TEXT);
expect(sections[1].content).toBe('Reading file1...');
expect(sections[2].type).toBe(AgenticSectionType.TOOL_CALL);
expect(sections[2].toolName).toBe('read_file');
expect(sections[3].type).toBe(AgenticSectionType.REASONING);
expect(sections[4].type).toBe(AgenticSectionType.TEXT);
expect(sections[4].content).toBe('Here is the analysis.');
});
it('returns REASONING_PENDING when streaming with only reasoning content', () => {
const msg = makeAssistant({
reasoningContent: 'Let me think about this...'
});
const sections = deriveAgenticSections(msg, [], [], true);
expect(sections).toHaveLength(1);
expect(sections[0].type).toBe(AgenticSectionType.REASONING_PENDING);
expect(sections[0].content).toBe('Let me think about this...');
});
it('returns REASONING (not pending) when streaming but text content has appeared', () => {
const msg = makeAssistant({
content: 'The answer is',
reasoningContent: 'Let me think...'
});
const sections = deriveAgenticSections(msg, [], [], true);
expect(sections).toHaveLength(2);
expect(sections[0].type).toBe(AgenticSectionType.REASONING);
expect(sections[1].type).toBe(AgenticSectionType.TEXT);
});
it('returns REASONING (not pending) when not streaming', () => {
const msg = makeAssistant({
reasoningContent: 'Let me think...'
});
const sections = deriveAgenticSections(msg, [], [], false);
expect(sections).toHaveLength(1);
expect(sections[0].type).toBe(AgenticSectionType.REASONING);
});
it('multi-turn: streaming tool calls on last turn', () => {
const assistant1 = makeAssistant({
toolCalls: JSON.stringify([
{ function: { arguments: '{}', name: 'search' }, id: 'call_1', type: 'function' }
])
});
const tool1 = makeToolMsg({ content: 'result', toolCallId: 'call_1' });
const assistant2 = makeAssistant({ content: '', id: 'ast-2' });
const streamingToolCalls: ApiChatCompletionToolCall[] = [
{ function: { arguments: '{"pa', name: 'write_file' }, id: 'call_2', type: 'function' }
];
const sections = deriveAgenticSections(assistant1, [tool1, assistant2], streamingToolCalls);
// Turn 1: tool_call
// Turn 2 (streaming): streaming tool call
expect(sections.some((s) => s.type === AgenticSectionType.TOOL_CALL)).toBe(true);
expect(sections.some((s) => s.type === AgenticSectionType.TOOL_CALL_STREAMING)).toBe(true);
});
});
describe('hasAgenticContent', () => {
it('returns false for plain assistant', () => {
const msg = makeAssistant({ content: 'Just text' });
expect(hasAgenticContent(msg)).toBe(false);
});
it('returns true when message has toolCalls', () => {
const msg = makeAssistant({
toolCalls: JSON.stringify([
{ function: { arguments: '{}', name: 'test' }, id: 'call_1', type: 'function' }
])
});
expect(hasAgenticContent(msg)).toBe(true);
});
it('returns true when toolMessages are provided', () => {
const msg = makeAssistant();
const tool = makeToolMsg();
expect(hasAgenticContent(msg, [tool])).toBe(true);
});
it('returns false for empty toolCalls JSON', () => {
const msg = makeAssistant({ toolCalls: '[]' });
expect(hasAgenticContent(msg)).toBe(false);
});
});
// The turn-section cache: completed turns are immutable, so repeated
// derivations return the same section objects - which is what keeps tool
// block props stable while another turn streams. Every field the cache
// compares must invalidate it; a miss here renders stale content.
describe('completed turn section reuse', () => {
const toolCallsJson = JSON.stringify([
{ function: { arguments: '{"path":"/a"}', name: 'test' }, id: 'call_1', type: 'function' }
]);
function makeSession() {
return {
anchor: makeAssistant({
content: 'answer',
reasoningContent: 'thinking',
toolCalls: toolCallsJson
}),
tools: [makeToolMsg({ content: 'tool result', extra: [{ type: 'file' } as never] })]
};
}
it('returns the same section objects for unchanged inputs', () => {
const { anchor, tools } = makeSession();
const first = deriveAgenticSections(anchor, tools, [], false);
const second = deriveAgenticSections(anchor, tools, [], false);
expect(second[0]).toBe(first[0]);
expect(second[1]).toBe(first[1]);
});
it('recomputes when the assistant content changes', () => {
const { anchor, tools } = makeSession();
const first = deriveAgenticSections(anchor, tools, [], false);
anchor.content = 'edited';
const second = deriveAgenticSections(anchor, tools, [], false);
expect(second).not.toBe(first);
expect(second.some((s) => s.type === AgenticSectionType.TEXT && s.content === 'edited')).toBe(
true
);
});
it('recomputes when reasoning content changes', () => {
const { anchor, tools } = makeSession();
const first = deriveAgenticSections(anchor, tools, [], false);
anchor.reasoningContent = 'new thinking';
const second = deriveAgenticSections(anchor, tools, [], false);
expect(second).not.toBe(first);
});
it('recomputes when toolCalls change', () => {
const { anchor, tools } = makeSession();
const first = deriveAgenticSections(anchor, tools, [], false);
anchor.toolCalls = '[]';
const second = deriveAgenticSections(anchor, tools, [], false);
expect(second).not.toBe(first);
});
it('recomputes when a tool result or its extras change', () => {
const { anchor, tools } = makeSession();
const first = deriveAgenticSections(anchor, tools, [], false);
tools[0].content = 'new tool result';
expect(deriveAgenticSections(anchor, tools, [], false)).not.toBe(first);
const firstAfterContent = deriveAgenticSections(anchor, tools, [], false);
tools[0].extra = [{ type: 'image' } as never];
expect(deriveAgenticSections(anchor, tools, [], false)).not.toBe(firstAfterContent);
});
it('never reuses the streaming turn', () => {
const { anchor, tools } = makeSession();
const first = deriveAgenticSections(anchor, tools, [], true);
const second = deriveAgenticSections(anchor, tools, [], true);
expect(second).not.toBe(first);
});
it('keeps completed turns stable while the last turn streams', () => {
const anchor = makeAssistant({
content: 'turn one',
id: 'ast-1',
toolCalls: JSON.stringify([
{ function: { arguments: '{}', name: 'test' }, id: 'call_1', type: 'function' }
])
});
const continuation = makeAssistant({ content: 'turn two', id: 'ast-2' });
const tools = [
makeToolMsg({ content: 'r1', id: 'tool-1', toolCallId: 'call_1' }),
continuation,
makeToolMsg({ content: 'r2', id: 'tool-2', toolCallId: 'call_2' })
];
const first = deriveAgenticSections(anchor, tools, [], true);
const second = deriveAgenticSections(anchor, tools, [], true);
// turn one is complete: identical section objects across derivations
expect(second.slice(0, 2)).toEqual(first.slice(0, 2));
expect(second[0]).toBe(first[0]);
expect(second[1]).toBe(first[1]);
// the streaming last turn recomputed: fresh section objects
expect(second[second.length - 1]).not.toBe(first[first.length - 1]);
});
});