@adecore/agents-react 0.39.0 → 0.40.0

package/src/chat/logic/resume-compaction.ts

@@ -32,11 +32,13 @@ interface OfferInput {
 /* The newest turn by when it started, so a thread that arrives out of order still names the turn that ran last. */
 function lastTurn(items: readonly ChatItem[]): Turn | null {
     let last: Turn | null = null;
+
     for (const item of items) {
         if (item.kind === 'turn' && (last === null || item.createdAt >= last.createdAt)) {
             last = item;
         }
     }
+
     return last;
 }
 
@@ -45,24 +47,27 @@ function offerableTurn({ info, compaction, items, dismissedTurnId }: OfferInput)
     if (compaction === undefined || compaction === 'none') {
         return null;
     }
+
     if (info.activeTurnId !== null || (info.queue ?? []).length > 0) {
         return null;
     }
+
     if (info.usage.contextTokens < RESUME_COMPACTION_TOKENS) {
         return null;
     }
+
     const turn = lastTurn(items);
+
     if (turn === null || turn.endedAt === null || turn.id === dismissedTurnId) {
         return null;
     }
-    /*
-     * `contextTokens` keeps the old number until the next request, so without this the offer would
-     * come straight back after a compaction. A native compaction is a turn without a message of the
-     * person, which is why this looks at the turn and not at the last thing that was said.
-     */
+
+    // `contextTokens` keeps the old number until the next request, so the offer would return right after
+    // a compaction. A native one is a turn without a message of the person, hence the look at the turn.
     if (items.some((item) => item.kind === 'compaction' && item.turnId === turn.id)) {
         return null;
     }
+
     return turn;
 }
 
@@ -77,15 +82,18 @@ function dueAtOf(info: ChatInfo, endedAt: number): number {
  */
 export function resumeCompactionDueAt(input: OfferInput): number | null {
     const endedAt = offerableTurn(input)?.endedAt ?? null;
+
     return endedAt === null ? null : dueAtOf(input.info, endedAt);
 }
 
 /* Whether to offer compacting before the next message. */
 export function resumeCompactionOffer(input: OfferInput & { now: number }): ResumeCompactionOffer | null {
     const turn = offerableTurn(input);
+
     if (turn === null || turn.endedAt === null || input.now < dueAtOf(input.info, turn.endedAt)) {
         return null;
     }
+
     return {
         turnId: turn.id,
         tokens: input.info.usage.contextTokens,
@@ -109,30 +117,39 @@ export interface DueClock {
 export function watchDueAt(dueAt: number, due: (now: number) => void, clock: DueClock): () => void {
     let timer: unknown = null;
     let done = false;
+
     const check = (): void => {
         if (timer !== null) {
             clock.clearTimer(timer);
             timer = null;
         }
+
         if (done) {
             return;
         }
+
         const now = clock.now();
+
         if (now >= dueAt) {
             done = true;
             due(now);
+
             return;
         }
+
         timer = clock.setTimer(() => {
             timer = null;
             check();
         }, dueAt - now);
     };
+
     const stopWake = clock.onWake(check);
     check();
+
     return () => {
         done = true;
         stopWake();
+
         if (timer !== null) {
             clock.clearTimer(timer);
         }

package/src/chat/logic/scrubber.ts

@@ -2,11 +2,7 @@ import type { ChatBookmark } from '@adecore/agent-contracts';
 import type { TimelineRow } from './timeline';
 import { DEFAULT_READING_WIDTH, readingMeasure } from '../reading-width';
 
-/*
- * The strip at the left edge of a chat view with a tick per message a person sent, as numbers: which
- * rows get a tick, where the ticks go in the height the strip has, which messages are on screen, and
- * which one a pointer means. The component only draws what comes out of here.
- */
+// The strip of ticks at the left edge of a chat view, as numbers; the component only draws what comes out of here.
 
 /* A message the person sent, a turn the machine opened with the results of tasks, or any other message with a bookmark on it. */
 export type TickKind = 'person' | 'wake' | 'bookmark';
@@ -33,6 +29,7 @@ const MIN_PITCH_PX = 4;
 
 /* The scroller's padding around the thread's content column (`px-4`). */
 const THREAD_PADDING_PX = 16;
+
 export const STRIP_WIDTH_PX = 24;
 /* The strip's distance from the view's left edge, and the air it keeps between itself and the thread's text. */
 export const STRIP_INSET_PX = 8;
@@ -48,23 +45,30 @@ const WIDTH_WAKE_PX = 5;
 export function ticksOf(rows: readonly TimelineRow[], marks: ReadonlyMap<string, ChatBookmark> = new Map()): ScrubberTick[] {
     return rows.flatMap((row, rowIndex): ScrubberTick[] => {
         const bookmark = marks.get(row.id) ?? null;
+
         if (row.kind === 'user') {
             // A message of only attachments still has a place in the thread; its names stand in for the text.
             const text = row.item.text !== '' ? row.item.text : (row.item.attachments ?? []).map((attachment) => attachment.name).join(', ');
+
             return [{ id: row.id, rowIndex, kind: 'person', text, createdAt: row.item.createdAt, turnId: row.item.turnId, bookmark }];
         }
+
         // The other turns nobody asked for (a sub-agent that finished, the CLI going on) are no place to return to.
         if (row.kind === 'turn-start' && ((row.turn.taskIds?.length ?? 0) > 0 || (row.turn.messageFrom?.length ?? 0) > 0)) {
             return [{ id: row.id, rowIndex, kind: 'wake', text: row.label, createdAt: row.turn.createdAt, turnId: row.turn.id, bookmark: null }];
         }
+
         if (bookmark === null) {
             return [];
         }
+
         if (row.kind === 'assistant') {
             return [{ id: row.id, rowIndex, kind: 'bookmark', text: row.item.text, createdAt: row.item.createdAt, turnId: row.item.turnId, bookmark }];
         }
+
         // The fold of a turn a marked reply is hidden in; the card reads the start the bookmark kept.
         const turnId = row.kind === 'turn-fold' ? row.turn.id : null;
+
         return [{ id: row.id, rowIndex, kind: 'bookmark', text: bookmark.excerpt, createdAt: bookmark.createdAt, turnId, bookmark }];
     });
 }
@@ -94,19 +98,23 @@ export function layoutTicks(kinds: readonly TickKind[], height: number, marked:
     const count = kinds.length;
     const room = Math.max(0, Math.floor(height));
     const slotCount = Math.min(count, Math.floor(room / MIN_PITCH_PX));
+
     if (slotCount === 0) {
         return { top: 0, pitch: MIN_PITCH_PX, count, slots: [] };
     }
+
     const pitch = Math.min(PITCH_PX, Math.floor(room / slotCount));
     const top = Math.floor((room - slotCount * pitch) / 2);
     const inset = Math.floor((pitch - TICK_HEIGHT_PX) / 2);
     const slots: TickSlot[] = [];
+
     for (let i = 0; i < slotCount; i++) {
         const first = Math.floor((i * count) / slotCount);
         const last = Math.floor(((i + 1) * count) / slotCount) - 1;
         // A merged tick is the person's as soon as one message in it is, since those are what the strip is for.
         const run = kinds.slice(first, last + 1);
         const kind = run.includes('person') ? 'person' : run.includes('bookmark') ? 'bookmark' : 'wake';
+
         slots.push({
             first,
             last,
@@ -116,6 +124,7 @@ export function layoutTicks(kinds: readonly TickKind[], height: number, marked:
             y: top + i * pitch + inset
         });
     }
+
     return { top, pitch, count, slots };
 }
 
@@ -127,6 +136,7 @@ export function tickOfRow(ticks: readonly ScrubberTick[], rowIndex: number): num
     if (ticks.length === 0) {
         return null;
     }
+
     return Math.max(
         0,
         lastIndexAtOrBelow(ticks.length, (index) => ticks[index]!.rowIndex, rowIndex)
@@ -136,25 +146,31 @@ export function tickOfRow(ticks: readonly ScrubberTick[], rowIndex: number): num
 /* Per tick, whether any of the rows has a find hit in its stretch. */
 export function ticksWithHits(ticks: readonly ScrubberTick[], hitRows: readonly number[]): boolean[] {
     const found = ticks.map(() => false);
+
     for (const row of hitRows) {
         const tick = tickOfRow(ticks, row);
+
         if (tick !== null) {
             found[tick] = true;
         }
     }
+
     return found;
 }
 
 /* The message under a height in the strip; inside a merged tick the height picks among its messages. */
 export function messageAt(layout: ScrubberLayout, y: number): number | null {
     const { slots, top, pitch } = layout;
+
     if (slots.length === 0) {
         return null;
     }
+
     const offset = y - top;
     const index = Math.min(slots.length - 1, Math.max(0, Math.floor(offset / pitch)));
     const slot = slots[index]!;
     const fraction = Math.min(1, Math.max(0, (offset - index * pitch) / pitch));
+
     return slot.first + Math.min(slot.last - slot.first, Math.floor(fraction * (slot.last - slot.first + 1)));
 }
 
@@ -162,9 +178,11 @@ export function slotOf(layout: ScrubberLayout, message: number): number | null {
     const { slots } = layout;
     let low = 0;
     let high = slots.length - 1;
+
     while (low <= high) {
         const middle = (low + high) >> 1;
         const slot = slots[middle]!;
+
         if (message < slot.first) {
             high = middle - 1;
         } else if (message > slot.last) {
@@ -173,6 +191,7 @@ export function slotOf(layout: ScrubberLayout, message: number): number | null {
             return middle;
         }
     }
+
     return null;
 }
 
@@ -184,9 +203,11 @@ export function tickWidth(kind: TickKind, distanceFromPointer: number | null): n
     if (distanceFromPointer === 0) {
         return WIDTH_HOVERED_PX;
     }
+
     if (distanceFromPointer === 1) {
         return kind === 'wake' ? WIDTH_NEAR_WAKE_PX : WIDTH_NEAR_PERSON_PX;
     }
+
     return kind === 'wake' ? WIDTH_WAKE_PX : WIDTH_PERSON_PX;
 }
 
@@ -195,8 +216,10 @@ function lastIndexAtOrBelow(length: number, valueAt: (index: number) => number,
     let low = 0;
     let high = length - 1;
     let found = -1;
+
     while (low <= high) {
         const middle = (low + high) >> 1;
+
         if (valueAt(middle) <= limit) {
             found = middle;
             low = middle + 1;
@@ -204,6 +227,7 @@ function lastIndexAtOrBelow(length: number, valueAt: (index: number) => number,
             high = middle - 1;
         }
     }
+
     return found;
 }
 
@@ -233,15 +257,19 @@ export interface MessageRange {
  */
 export function messagesInView({ starts, scrollTop, visibleHeight }: ReadingPosition): MessageRange | null {
     const bottom = scrollTop + visibleHeight;
+
     if (starts.length === 0 || visibleHeight <= 0 || starts.at(0)! >= bottom) {
         return null;
     }
+
     const first = Math.max(0, lastAtOrAbove(starts, scrollTop));
     let last = lastAtOrAbove(starts, bottom);
+
     // A row that starts on the very last line has not a pixel on screen yet.
     if (starts.at(last)! >= bottom) {
         last--;
     }
+
     return { first, last: Math.max(first, last) };
 }
 
@@ -262,13 +290,16 @@ export function stepMessage(starts: MessageStarts, eligible: (index: number) =>
                 return i;
             }
         }
+
         return null;
     }
+
     for (let i = lastAtOrAbove(starts, scrollTop + 1) + 1; i < starts.length; i++) {
         if (eligible(i)) {
             return i;
         }
     }
+
     return null;
 }
 
@@ -282,7 +313,9 @@ export function threadPaddingLeft(width: number, strip: boolean, measure = readi
     if (!strip) {
         return THREAD_PADDING_PX;
     }
+
     // The column's margin is half of what the padding leaves, so the padding counts the clearance twice.
     const padding = 2 * STRIP_CLEARANCE_PX + measure + THREAD_PADDING_PX - Math.floor(width);
+
     return Math.min(STRIP_CLEARANCE_PX, Math.max(THREAD_PADDING_PX, padding));
 }

package/src/chat/logic/thought.ts

@@ -18,6 +18,7 @@ function headingOf(line: string): string | null {
 /* What a folded thought shows on its one line: the heading it opens with, or the whole thought flattened for the row to cut off. */
 export function thoughtPreview(text: string): string {
     const heading = headingOf(text.trimStart().split('\n', 1)[0] ?? '');
+
     return flattenThought(heading ?? text);
 }
 
@@ -30,11 +31,15 @@ export function thoughtLine(text: string): string {
         .split('\n')
         .map(headingOf)
         .filter((heading): heading is string => heading !== null);
+
     const last = headings.at(-1);
+
     if (last !== undefined) {
         return flattenThought(last);
     }
+
     const flat = flattenThought(text);
     const end = SENTENCE_END.exec(flat);
+
     return end === null ? flat : flat.slice(0, end.index + end[0].length);
 }

package/src/chat/logic/thread-cards.ts

@@ -67,21 +67,27 @@ export function withTimedRows(rows: TimelineRow[], timed: readonly TimedRow[]):
     if (timed.length === 0) {
         return rows;
     }
+
     // Sorting is stable, which is what keeps rows of the same moment in the order they came.
     const pending = [...timed].sort((first, second) => first.at - second.at);
     const merged: TimelineRow[] = [];
     let next = 0;
+
     for (const row of rows) {
         const time = rowTime(row);
+
         while (time !== null && next < pending.length && pending[next]!.at < time) {
             merged.push(pending[next]!.row);
             next += 1;
         }
+
         merged.push(row);
     }
+
     for (; next < pending.length; next++) {
         merged.push(pending[next]!.row);
     }
+
     return merged;
 }
 

package/src/chat/logic/timeline-copy.ts

@@ -2,15 +2,8 @@ import type { TimelineRow } from './timeline';
 import { stripAnsi } from './ansi';
 
 /*
- * What a row of the thread puts on the clipboard. An answer is markdown on the wire and rendered
- * text on the screen, so copying it as text has to undo the marks the renderer swallowed; the
- * source itself stays available as "Copy as Markdown".
- */
-
-/*
- * The marks that only exist to be rendered come off, what they marked stays. `_` is left alone on
- * purpose: it is a letter in half the identifiers an agent writes, and no italic is worth mangling
- * `file_path`.
+ * An answer is markdown on the wire and rendered text on screen, so a copy as text undoes the marks the
+ * renderer swallowed. `_` stays: it is a letter in half the identifiers an agent writes (`file_path`).
  */
 export function stripMarkdown(text: string): string {
     return text
@@ -28,6 +21,7 @@ export function stripMarkdown(text: string): string {
 /* What a tool call has to show for itself: what it answered, or what it has answered so far. */
 function outputOf(tool: { output: string | null; progress?: { output: string | null } }): string | null {
     const output = tool.output ?? tool.progress?.output ?? null;
+
     return output === null ? null : stripAnsi(output);
 }
 
@@ -48,6 +42,7 @@ export function messageTextOf(row: TimelineRow): string | null {
             return outputOf(row.tool);
         case 'work-group': {
             const outputs = row.tools.map(outputOf).filter((output): output is string => output !== null);
+
             return outputs.length > 0 ? outputs.join('\n\n') : null;
         }
         case 'subagent':

package/src/chat/logic/timeline-target.ts

@@ -28,14 +28,18 @@ export function withCurrentText(rows: TimelineRow[], items: Record<string, ChatI
     if (!items) {
         return rows;
     }
+
     return rows.map((row) => {
         const item = items[row.id];
+
         if (row.kind === 'assistant' && item?.kind === 'assistant') {
             return { ...row, item };
         }
+
         if (row.kind === 'thinking' && item?.kind === 'thinking') {
             return { ...row, item };
         }
+
         return row;
     });
 }
@@ -48,6 +52,7 @@ export function readTimelineTarget(element: HTMLElement, scroller: HTMLElement |
     const column = positiveInteger(file?.dataset.fileColumn);
     const endLine = positiveInteger(file?.dataset.fileEndLine);
     const path = file?.dataset.filePath ?? null;
+
     return {
         selection: selectionWithin(scroller),
         row: rows.find((row) => row.id === id) ?? null,
@@ -73,6 +78,7 @@ export function readTimelineTarget(element: HTMLElement, scroller: HTMLElement |
 
 function positiveInteger(value: string | undefined): number | null {
     const number = Number(value);
+
     return Number.isSafeInteger(number) && number > 0 ? number : null;
 }
 
@@ -87,31 +93,40 @@ export function uiReplyJump(
     hasEarlier: boolean
 ): UiReplyJump {
     const item = items?.[target.itemId];
+
     if (!item) {
         return { kind: hasEarlier ? 'earlier' : 'missing' };
     }
+
     if (item.kind !== 'assistant' || !item.ui?.some((block) => block.id === target.blockId && block.revision === target.revision)) {
         return { kind: 'missing' };
     }
+
     const index = rows.findIndex((row) => row.kind === 'assistant' && row.id === target.itemId);
+
     if (index !== -1) {
         return { kind: 'row', index };
     }
+
     return item.turnId && !expandedTurns.has(item.turnId) ? { kind: 'turn', turnId: item.turnId } : { kind: 'missing' };
 }
 
 export function revealUiReplyBlock(scroller: HTMLElement, target: UiReplyTarget): boolean {
     // Compare attributes instead of interpolating provider ids into CSS selectors.
     const row = Array.from(scroller.querySelectorAll<HTMLElement>('[data-item-id]')).find((element) => element.dataset.itemId === target.itemId);
+
     const block =
         row &&
         Array.from(row.querySelectorAll<HTMLElement>('[data-ui-block]')).find(
             (element) => element.dataset.uiBlock === target.blockId && element.dataset.uiRevision === target.revision
         );
+
     if (!block) {
         return false;
     }
+
     scroller.scrollTop += block.getBoundingClientRect().top - scroller.getBoundingClientRect().top;
     block.focus({ preventScroll: true });
+
     return true;
 }