Merge branch 'main' into web-chat-composer

# Conflicts:
#	web/src/app.js
#	web/src/client.js
#	web/src/protocol.js
#	web/test/chat.test.mjs
#	web/test/repository.test.mjs
#	web/test/ui-smoke.mjs
This commit is contained in:
2026-10-19 07:33:49 +01:00
14 changed files with 1840 additions and 39 deletions
+353
View File
@@ -747,6 +747,359 @@ export function mergeHistoryPage(previous, page, { older = false } = {}) {
};
}
// ---------------------------------------------------------------------------
// Live stream folding (ChatStore.kt event/applyRemoteUser/applyDelta/applyTool,
// ChatFormat.kt deltaPartId/mergeToolPart/turnPhase)
// ---------------------------------------------------------------------------
/** ChatEvent.Kind values pushed on the `chat_event` stream (internal/protocol/chat.go). */
export const EVENT_STEP = "step";
export const EVENT_USAGE = "usage";
export const EVENT_USER = "user";
export const EVENT_SHELL = "shell";
/** ChatStep.Status values. `ended` is the one status that settles a turn. */
export const STEP_ENDED = "ended";
/**
* How recently a text or reasoning delta must have arrived for a turn to read as
* still thinking. Long enough that the indicator's tick cannot flicker between
* thinking and waiting on a steady stream, short enough that a stalled turn
* starts reading as waiting while the operator still wonders.
*/
export const TURN_THINKING_WINDOW_MILLIS = 2500;
/** The three things an in-flight turn can be doing (ChatFormat.kt TurnPhase). */
export const TURN_PHASE_THINKING = "thinking";
export const TURN_PHASE_TOOL = "tool";
export const TURN_PHASE_WAITING = "waiting";
/**
* The live-stream badge words, shared verbatim with `liveBadgeState` /
* RunStream.kt: the stream is `live` only while a session is subscribed on a
* connected socket, `reconnecting` while the socket is coming back (pushes are
* paused in the gap) and `not live` when idle or when the server refused the
* subscription. The word always carries the meaning, so colour is never the only
* signal.
*/
export const STREAM_LIVE = "live";
export const STREAM_RECONNECTING = "reconnecting";
export const STREAM_OFFLINE = "not live";
/** The badge for [connectionKind] (`connected`/`connecting`/`disconnected`/`idle`). */
export function chatStreamState(connectionKind, subscribed) {
if (connectionKind === "connected" && subscribed) return { tone: "live", label: STREAM_LIVE };
if (connectionKind === "connecting" || connectionKind === "disconnected") {
return { tone: "reconnecting", label: STREAM_RECONNECTING };
}
return { tone: "not-live", label: STREAM_OFFLINE };
}
/**
* The shape an open conversation holds. The first six fields are the ones a
* history page fills; the rest is the live stream (see `ChatThread` in
* ChatStore.kt). A Map is deliberately not used for [toolStartedAt] so a thread
* stays a plain, comparable value.
*/
export function newChatThread(sessionId = "") {
return {
sessionId,
messages: [],
nextCursor: "",
hasMore: false,
loaded: false,
loading: false,
error: "",
running: false,
runningSince: 0,
toolStartedAt: {},
lastDeltaAt: 0,
queued: false,
};
}
/**
* The settled form of a thread: no turn is in flight, so the elapsed stamps and
* the queued flag are cleared. The one place a thread stops running, so the
* indicator and its stamps can never disagree. A no-op (returns [thread]) when it
* was already settled.
*/
export function settledThread(thread) {
return {
...(thread ?? {}),
running: false,
runningSince: 0,
toolStartedAt: {},
lastDeltaAt: 0,
queued: false,
};
}
/** Applies a running transition, stamping `runningSince` the moment it begins. */
export function setThreadRunning(thread, running, now) {
if (running) return thread.running ? thread : { ...thread, running: true, runningSince: now };
return settledThread({ ...thread });
}
/**
* Non-negative elapsed time of an in-flight turn at [nowMillis], or 0 once it has
* settled. Pure, so the running indicator and its unit test share the derivation.
*/
export function threadElapsedMillis(thread, nowMillis) {
const since = Number(thread?.runningSince) || 0;
return thread?.running && since >= 1 && since < nowMillis ? nowMillis - since : 0;
}
/** Every tool call still in flight across a conversation's [messages]. */
export function threadRunningTools(messages) {
return runningTools((messages ?? []).flatMap((message) => message?.parts ?? []));
}
/** How long [part] has been running at [nowMillis], using the thread's own stamps. */
export function threadToolElapsedMillis(thread, part, nowMillis) {
const stamps = thread?.toolStartedAt ?? {};
const startedAt = stamps instanceof Map ? (stamps.get(part?.id) ?? 0) : (stamps[part?.id] ?? 0);
return runningToolElapsedMillis(part, startedAt, nowMillis);
}
/**
* The id a text or reasoning delta must be applied to for [kind] within [parts].
* The broker gives the two kinds distinct ids (see `ChatDeltaPartID`), but a peer
* that still shares one bare id between them must never have answer text appended
* into a reasoning part: when another kind already holds the bare id, the delta is
* moved onto a suffixed id of its own. Once a part of this kind exists under
* either id, that part is the one addressed, so a stream keeps growing the part
* it started.
*/
export function deltaPartId(parts, kind, id) {
const list = parts ?? [];
if (list.some((part) => part?.type === kind && part?.id === id)) return id;
const suffixed = `${id}#${kind}`;
if (list.some((part) => part?.type === kind && part?.id === suffixed)) return suffixed;
return list.some((part) => part?.id === id) ? suffixed : id;
}
/**
* Folds one tool frame's part onto the part retained from earlier frames. A tool
* call is reported across several frames that each carry only part of it, so a
* field already learned is never blanked by a later frame that omits it. A
* non-empty incoming field wins; otherwise the retained value is kept.
*/
export function mergeToolPart(previous, incoming) {
if (previous == null) return incoming;
return {
...incoming,
type: isBlank(incoming?.type) ? previous.type : incoming.type,
name: isBlank(incoming?.name) ? previous.name : incoming.name,
executed: Boolean(incoming?.executed || previous?.executed),
time: incoming?.time ?? previous?.time,
state: mergeToolState(previous?.state, incoming?.state),
};
}
function mergeToolState(prior, incoming) {
if (incoming == null) return prior ?? undefined;
if (prior == null) return incoming;
return {
...incoming,
status: isBlank(incoming.status) ? prior.status : incoming.status,
input: incoming.input == null ? prior.input : incoming.input,
content: (incoming.content ?? []).length > 0 ? incoming.content : prior.content,
metadata: incoming.metadata ?? prior.metadata,
error: incoming.error ?? prior.error,
};
}
/**
* The running-tool start stamps after a thread's [messages] changed: every tool
* part in flight keeps the stamp it already had, or is stamped with [now] when it
* has just turned running, and a part that is no longer running loses its stamp.
*/
export function runningToolStamps(current, messages, now) {
const stamps = {};
for (const message of messages ?? []) {
for (const part of message?.parts ?? []) {
if (!isBlank(part?.id) && part?.type === PART_TOOL && toolRunning(part)) {
stamps[part.id] = current?.[part.id] ?? now;
}
}
}
return stamps;
}
/**
* The [TURN_PHASE_*] of a turn in flight. [tools] are the calls the stream still
* reports running; [silentMillis] is how long ago the last text or reasoning
* delta arrived, or null when none has. No percentage, ETA or progress is
* invented — the only inputs are the calls the stream reported and the time since
* the last delta.
*/
export function turnPhase(tools, silentMillis) {
if ((tools ?? []).length > 0) return TURN_PHASE_TOOL;
if (silentMillis != null && silentMillis >= 0 && silentMillis < TURN_THINKING_WINDOW_MILLIS) {
return TURN_PHASE_THINKING;
}
return TURN_PHASE_WAITING;
}
/** The running indicator's headline for [phase], naming what is happening. */
export function turnPhaseLabel(phase) {
if (phase === TURN_PHASE_THINKING) return "Thinking…";
if (phase === TURN_PHASE_TOOL) return "Running a tool…";
return "Waiting…";
}
/**
* The turn's phase at [nowMillis], derived from its running tools and the time
* since its last delta. Null when nothing is running, so a settled turn has no
* phase at all.
*/
export function threadPhase(thread, nowMillis) {
if (!thread?.running) return null;
const last = Number(thread.lastDeltaAt) || 0;
const silent = last >= 1 && last < nowMillis ? nowMillis - last : null;
return turnPhase(threadRunningTools(thread.messages), silent);
}
/**
* Applies one pushed `chat_event` frame to a conversation and returns the next
* thread. Any frame clears `queued` (the turn moved on); `user` echoes another
* client's prompt once (never this client's own), `text`/`reasoning` append to the
* part their kind started, `tool` merges field by field, `step` drives the running
* flag, and `shell`/`usage` are recognised but not folded here (C11 owns shells
* and the turn totals are not shown). The message that a delta or tool frame
* targets is created on first sight, so a live turn never gains a second bubble.
*/
export function applyChatEvent(thread, frame, now = Date.now()) {
const current = thread?.queued
? { ...thread, queued: false }
: (thread ?? newChatThread(str(frame?.session_id)));
switch (frame?.kind) {
case EVENT_USER:
return applyRemoteUser(current, frame);
case PART_TEXT:
case PART_REASONING:
return applyDelta(current, frame, now);
case PART_TOOL:
return applyTool(current, frame, now);
case EVENT_STEP:
return setThreadRunning(current, str(frame?.step?.status) !== STEP_ENDED, now);
// `shell` is C11's (it never marks the turn running) and `usage` is not
// folded; both still clear `queued`, which happened above.
case EVENT_SHELL:
case EVENT_USAGE:
default:
return current;
}
}
/**
* Folds a user turn another client sent into the transcript, in place, once. The
* server never echoes this client's own prompts, so the sender's own message is
* never duplicated; the message's `client` label says which device sent it.
*/
function applyRemoteUser(thread, frame) {
const text = str(frame?.part?.text);
const messageId = str(frame?.message_id);
if (messageId === "" || text === "") return thread;
const operationId = str(frame?.operation_id);
const messages = thread.messages ?? [];
if (
operationId !== "" &&
messages.some((message) => message?.role === ROLE_USER && str(message?.operation_id) === operationId)
) {
return thread;
}
if (messages.some((message) => message?.id === messageId)) return thread;
const message = {
id: messageId,
session_id: str(frame?.session_id),
role: ROLE_USER,
client: str(frame?.client),
operation_id: operationId,
parts: [{ type: PART_TEXT, text }],
};
return { ...thread, messages: [...messages, message] };
}
function applyDelta(thread, frame, now) {
const rawId = str(frame?.part?.id);
const delta = str(frame?.delta);
if (rawId === "" || delta === "") return thread;
const kind = frame.kind;
return upsertParts(thread, frame, now, now, (parts) => {
const id = deltaPartId(parts, kind, rawId);
const index = parts.findIndex((part) => part?.id === id);
if (index < 0) return [...parts, { type: kind, id, text: delta }];
const next = parts.slice();
next[index] = { ...next[index], text: str(next[index]?.text) + delta };
return next;
});
}
function applyTool(thread, frame, now) {
const incoming = frame?.part ?? null;
if (incoming == null || str(incoming.id) === "") return thread;
return upsertParts(thread, frame, now, null, (parts) => {
const index = parts.findIndex((part) => part?.id === incoming.id && part?.type === PART_TOOL);
if (index < 0) return [...parts, mergeToolPart(null, incoming)];
const next = parts.slice();
next[index] = mergeToolPart(next[index], incoming);
return next;
});
}
/**
* Finds or creates the assistant message [frame] targets and replaces its parts
* with [upsert]'s result, then marks the thread running. The text/reasoning fold
* and the tool upsert share this so the two cannot drift.
*/
function upsertParts(thread, frame, now, deltaArrivedAt, upsert) {
const messageId = str(frame?.message_id);
const messages = (thread.messages ?? []).slice();
let index = -1;
for (let i = messages.length - 1; i >= 0; i -= 1) {
if (messages[i]?.id === messageId) {
index = i;
break;
}
}
if (index < 0) {
messages.push({
id: messageId,
session_id: str(frame?.session_id),
role: ROLE_ASSISTANT,
parts: [],
});
index = messages.length - 1;
}
const message = messages[index];
messages[index] = { ...message, parts: upsert(message.parts ?? []) };
const stamped = runningToolStamps(thread.toolStartedAt, messages, now);
let next = setThreadRunning({ ...thread, messages, toolStartedAt: stamped }, true, now);
if (deltaArrivedAt != null) next = { ...next, lastDeltaAt: deltaArrivedAt };
return next;
}
/**
* The reconnect/resync replacement: the newest history page is authoritative, so
* the whole turn is replaced (no stale held message survives), the cursor and
* `hasMore` are replaced from the page, and any in-flight state is settled —
* every frame that was feeding a running turn is gone.
*/
export function historyResync(thread, page) {
const settled = settledThread(thread ?? newChatThread());
return {
...settled,
messages: (page?.messages ?? []).slice(),
nextCursor: str(page?.nextCursor),
hasMore: Boolean(page?.hasMore),
loaded: true,
loading: false,
error: "",
};
}
// ---------------------------------------------------------------------------
// Scroll behaviour (ChatScroll.kt)
// ---------------------------------------------------------------------------