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:
+353
@@ -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)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
Reference in New Issue
Block a user