@adecore/agents-react 0.38.0 → 0.40.0

package/src/chat/logic/timeline.ts

@@ -95,12 +95,15 @@ function lookSummary(tools: readonly ChatToolItem[], looks: readonly CommandLook
     let look: CommandLook | null = null;
     let group: { key: string; sentence(count: number): string } | undefined;
     let sameKey = true;
+
     for (const tool of tools) {
         const command = shellCommand(tool.name, tool.input);
         const run = command === null ? null : matchCommandLook(command, looks);
+
         if (run === null || (look !== null && run.look !== look)) {
             return null;
         }
+
         if (look === null) {
             look = run.look;
             group = run.match.group;
@@ -108,35 +111,45 @@ function lookSummary(tools: readonly ChatToolItem[], looks: readonly CommandLook
             sameKey = false;
         }
     }
+
     if (look === null) {
         return null;
     }
+
     if (sameKey && group !== undefined) {
         return { look, summary: group.sentence(tools.length) };
     }
+
     return look.sentence === undefined ? null : { look, summary: look.sentence(tools.length) };
 }
 
 /* "Read 4 files", "Ran 2 commands", "12 tool calls" when the run mixes kinds, or the sentence of a look all its calls are runs of. */
 export function summarizeGroup(tools: ChatToolItem[], looks?: readonly CommandLook[]): string {
     const looked = lookSummary(tools, looks);
+
     if (looked !== null) {
         return looked.summary;
     }
+
     const names = new Set(tools.map((tool) => tool.name));
     const only = names.size === 1 ? tools[0]!.name : null;
     const failed = tools.filter(failedFileChange);
+
     if (only !== null && toolEntry(only)?.grouped === true && failed.length === 0) {
         return i18next.t(`agent-chat:group.tools.${only}`, { count: tools.length });
     }
+
     // Counts the files rather than the calls: three edits to one file are one file edited.
     if (tools.every((tool) => isFileChange(tool.name)) && failed.length < tools.length) {
         const paths = new Set(tools.filter((tool) => !failedFileChange(tool)).map(editedPath));
+
         return i18next.t('agent-chat:group.edited', { count: paths.size });
     }
+
     if (only !== null) {
         return i18next.t('agent-chat:group.calls', { name: only, count: tools.length });
     }
+
     return i18next.t('agent-chat:group.toolCalls', { count: tools.length });
 }
 
@@ -157,20 +170,25 @@ function editedPath(tool: ChatToolItem): string {
 export function summarizeTurn(tools: readonly ChatToolItem[], looks?: readonly CommandLook[]): string[] {
     // Keyed by the sentence, so its place is where the first call of that kind came.
     const counts = new Map<string, { count: number; say(count: number): string }>();
+
     const add = (key: string, say: (count: number) => string, total?: number): void => {
         const known = counts.get(key);
+
         if (known === undefined) {
             counts.set(key, { count: total ?? 1, say });
         } else {
             known.count = total ?? known.count + 1;
         }
     };
+
     const edited = new Set<string>();
     let other = 0;
+
     for (const tool of tools) {
         const command = shellCommand(tool.name, tool.input);
         const run = command === null ? null : matchCommandLook(command, looks);
         const group = run?.match.group;
+
         if (run !== null && group !== undefined) {
             // Keyed by the program too, so two looks with a key in common keep their own sentences.
             add(`look:${run.look.program}:${group.key}`, group.sentence);
@@ -186,10 +204,13 @@ export function summarizeTurn(tools: readonly ChatToolItem[], looks?: readonly C
             other += 1;
         }
     }
+
     const parts = [...counts.values()].map(({ count, say }) => say(count));
+
     if (other > 0) {
         parts.push(i18next.t(parts.length === 0 ? 'agent-chat:group.toolCalls' : 'agent-chat:group.otherCalls', { count: other }));
     }
+
     return parts;
 }
 
@@ -199,20 +220,24 @@ export function summarizeTurn(tools: readonly ChatToolItem[], looks?: readonly C
  */
 export function agentTurnLabel(turn: ChatTurnItem): string {
     const about = (what: string): string => (turn.label ? i18next.t('agent-chat:turn.about', { what, label: turn.label }) : what);
+
     // A turn the machine opened with the results of tasks this chat gave; the label is their titles.
     if (turn.taskIds !== undefined && turn.taskIds.length > 0) {
         return about(i18next.t('agent-chat:turn.wokenByTask', { count: turn.taskIds.length }));
     }
+
     // A turn the machine opened over a message another node sent; the label names who sent it.
     if (turn.messageFrom !== undefined && turn.messageFrom.length > 0) {
         return about(i18next.t('agent-chat:turn.wokenByMessage', { count: turn.messageFrom.length }));
     }
+
     return turn.label ? i18next.t('agent-chat:turn.subagentFinished', { label: turn.label }) : i18next.t('agent-chat:turn.continued');
 }
 
 /* The items of the turn tell a turn a person stopped from one the machine ended after a restart. */
 export function turnLabel(turn: ChatTurnItem, items: readonly ChatItem[] = []): string {
     const duration = formatElapsedShort((turn.endedAt ?? turn.createdAt) - turn.createdAt);
+
     switch (turn.state) {
         case 'aborted':
             return abortedByMachine(turn, items) ? i18next.t('agent-chat:turn.stopped', { duration }) : i18next.t('agent-chat:turn.youStopped', { duration });
@@ -233,6 +258,7 @@ const MAX_NESTING = 8;
 
 function branchOf(item: ChatSubagentItem, options: TimelineOptions, children: Map<string, ChatItem[]>, depth = 0): SubagentBranch {
     const own = children.get(item.toolUseId) ?? [];
+
     return {
         id: item.id,
         item,
@@ -251,39 +277,50 @@ export function findSubagentBranch(rows: readonly TimelineRow[], toolUseId: stri
         if (branch.item.toolUseId === toolUseId) {
             return branch;
         }
+
         for (const child of branch.nested) {
             const found = search(child);
+
             if (found) {
                 return found;
             }
         }
+
         return null;
     };
+
     for (let index = 0; index < rows.length; index++) {
         const row = rows[index]!;
         const branch = row.kind === 'subagent' ? search(row) : null;
+
         if (branch) {
             return { index, branch };
         }
     }
+
     return null;
 }
 
 /* What each subagent did, keyed by the call that spawned it, in the order it happened. */
 function groupChildren(items: ChatItem[]): Map<string, ChatItem[]> {
     const children = new Map<string, ChatItem[]>();
+
     for (const item of items) {
         const parent = parentOf(item);
+
         if (parent === null) {
             continue;
         }
+
         const bucket = children.get(parent);
+
         if (bucket) {
             bucket.push(item);
         } else {
             children.set(parent, [item]);
         }
     }
+
     return children;
 }
 
@@ -291,26 +328,31 @@ function flushTools(buffer: ChatToolItem[], rows: TimelineRow[], options: Timeli
     if (buffer.length === 0) {
         return;
     }
+
     const tools = buffer.splice(0);
     const live = tools.filter((tool) => tool.state === 'running');
     const settled = tools.filter((tool) => tool.state !== 'running');
+
     if (settled.length === 1) {
         rows.push({ kind: 'work', id: settled[0]!.id, tool: settled[0]! });
     } else if (settled.length > 1) {
         const id = `group-${settled[0]!.id}`;
         const expanded = options.expandedGroups.has(id);
         const looked = lookSummary(settled, options.commandLooks);
+
         rows.push(
             looked === null
                 ? { kind: 'work-group', id, tools: settled, summary: summarizeGroup(settled), expanded }
                 : { kind: 'work-group', id, tools: settled, summary: looked.summary, expanded, look: looked.look }
         );
+
         if (expanded) {
             for (const tool of settled) {
                 rows.push({ kind: 'work', id: tool.id, tool });
             }
         }
     }
+
     for (const tool of live) {
         rows.push({ kind: 'work-live', id: tool.id, tool });
     }
@@ -324,68 +366,90 @@ function isImageRow(row: TimelineRow): boolean {
 function rowsForItems(items: ChatItem[], options: TimelineOptions, children: Map<string, ChatItem[]>): TimelineRow[] {
     const rows: TimelineRow[] = [];
     const tools: ChatToolItem[] = [];
+
     for (const item of items) {
         if (parentOf(item) !== null) {
             continue;
         }
+
         const report = handbackReportOf(item);
+
         if (item.kind === 'tool' && item.workflow !== undefined) {
             flushTools(tools, rows, options);
             rows.push({ kind: 'workflow', id: item.id, tool: item, workflow: item.workflow });
+
             continue;
         }
+
         if (item.kind === 'tool' && isImageGeneration(item)) {
             flushTools(tools, rows, options);
             rows.push({ kind: item.state === 'running' ? 'work-live' : 'work', id: item.id, tool: item });
+
             continue;
         }
+
         if (item.kind === 'tool' && report === null) {
             tools.push(item);
+
             continue;
         }
+
         if (report !== null) {
             flushTools(tools, rows, options);
             rows.push({ kind: 'report', id: item.id, text: report });
+
             continue;
         }
+
         flushTools(tools, rows, options);
+
         switch (item.kind) {
             case 'subagent':
                 rows.push({ kind: 'subagent', ...branchOf(item, options, children) });
+
                 break;
             case 'user':
                 rows.push({ kind: 'user', id: item.id, item });
+
                 break;
             case 'assistant':
                 if (item.text !== '' || item.streaming) {
                     rows.push({ kind: 'assistant', id: item.id, item });
                 }
+
                 break;
             case 'thinking':
                 rows.push({ kind: 'thinking', id: item.id, item });
+
                 break;
             case 'approval':
                 // A pending one sits on the composer; only its outcome belongs in the transcript.
                 if (item.decision !== 'pending') {
                     rows.push({ kind: 'approval', id: item.id, item });
                 }
+
                 break;
             case 'question':
                 if (item.state !== 'pending') {
                     rows.push({ kind: 'question', id: item.id, item });
                 }
+
                 break;
             case 'note':
                 rows.push({ kind: 'note', id: item.id, level: item.level, text: item.text, ...(item.from === undefined ? {} : { from: item.from }) });
+
                 break;
             case 'compaction':
                 rows.push({ kind: 'compaction', id: item.id, preTokens: item.preTokens });
+
                 break;
             case 'turn':
                 break;
         }
     }
+
     flushTools(tools, rows, options);
+
     return rows;
 }
 
@@ -400,12 +464,16 @@ function changedFilesRow(turn: ChatTurnItem, items: ChatItem[]): TimelineRow | n
     const edits = items.filter(
         (item): item is ChatToolItem => item.kind === 'tool' && item.state === 'done' && isFileChange(item.name) && hasFileChanges(item)
     );
+
     const diff = turn.checkpointDiff ?? null;
     const empty = diff === null ? edits.length === 0 : diff.files.length === 0;
+
     if (empty) {
         return null;
     }
+
     const moved = turn.checkpointHead !== undefined && turn.checkpointHeadAfter !== undefined && turn.checkpointHead !== turn.checkpointHeadAfter;
+
     return {
         kind: 'changed-files',
         id: `files-${turn.id}`,
@@ -423,22 +491,29 @@ function changedFilesRow(turn: ChatTurnItem, items: ChatItem[]): TimelineRow | n
  */
 function lastAssistantRow(rows: TimelineRow[]): TimelineRow | null {
     const refused = new Set<string>();
+
     for (let i = rows.length - 1; i >= 0; i--) {
         const row = rows[i]!;
+
         if (row.kind === 'assistant') {
             return row;
         }
+
         if (row.kind === 'approval' && row.item.decision === 'deny' && row.item.toolUseId !== null) {
             refused.add(row.item.toolUseId);
+
             continue;
         }
+
         if (row.kind === 'work' && refused.has(row.tool.toolUseId)) {
             continue;
         }
+
         if (row.kind !== 'note' && !isImageRow(row)) {
             return null;
         }
     }
+
     return null;
 }
 
@@ -451,17 +526,21 @@ function lastAssistantRow(rows: TimelineRow[]): TimelineRow | null {
 function withLiveThought(rows: TimelineRow[], items: readonly ChatItem[]): TimelineRow[] {
     const thoughtAt = items.findLastIndex((item) => item.kind === 'thinking' && parentOf(item) === null);
     const thought = items[thoughtAt];
+
     if (thought?.kind !== 'thinking' || thought.text === '') {
         return rows;
     }
+
     const after = new Set(items.slice(thoughtAt + 1).map((item) => item.id));
     const index = rows.findIndex((row) => row.kind === 'work-live' && after.has(row.tool.id));
     const call = rows[index];
     const shownAt = rows.findIndex((row) => row.kind === 'thinking' && row.id === thought.id);
-    const inSight = shownAt !== -1 && shownAt < index && !rows.slice(shownAt + 1, index).some((row) => row.kind === 'work');
+    const inSight = shownAt !== -1 && shownAt < index && !rows.slice(shownAt + 1, index).some((row) => row.kind === 'work' || row.kind === 'work-group');
+
     if (call?.kind !== 'work-live' || inSight) {
         return rows;
     }
+
     return [...rows.slice(0, index), { kind: 'live-thought', id: `live-thought-${thought.id}`, item: thought, at: call.tool.createdAt }, ...rows.slice(index)];
 }
 
@@ -474,24 +553,31 @@ interface TurnChunk {
 function chunksByTurn(items: ChatItem[]): TurnChunk[] {
     const chunks: TurnChunk[] = [];
     const byTurn = new Map<string, ChatItem[]>();
+
     for (const item of items) {
         if (item.turnId === null) {
-            const last = chunks[chunks.length - 1];
-            if (last && last.turnId === null) {
+            const last = chunks.at(-1);
+
+            if (last?.turnId === null) {
                 last.items.push(item);
             } else {
                 chunks.push({ turnId: null, items: [item] });
             }
+
             continue;
         }
+
         let bucket = byTurn.get(item.turnId);
+
         if (!bucket) {
             bucket = [];
             byTurn.set(item.turnId, bucket);
             chunks.push({ turnId: item.turnId, items: bucket });
         }
+
         bucket.push(item);
     }
+
     return chunks;
 }
 
@@ -499,27 +585,36 @@ function chunksByTurn(items: ChatItem[]): TurnChunk[] {
 export function deriveTimelineRows(items: ChatItem[], options: TimelineOptions): TimelineRow[] {
     const rows: TimelineRow[] = [];
     const children = groupChildren(items);
+
     for (const chunk of chunksByTurn(items)) {
         if (chunk.turnId === null) {
             rows.push(...rowsForItems(chunk.items, options, children));
+
             continue;
         }
+
         const turnId = chunk.turnId;
         const turn = chunk.items.find((item): item is ChatTurnItem => item.kind === 'turn');
         const conversation = chunk.items.filter((item) => item.kind !== 'turn');
+
         if (turn?.origin === 'agent') {
             // The agent started this one itself, so there is no message of the person to show above it.
             rows.push({ kind: 'turn-start', id: `start-${turnId}`, turn, label: agentTurnLabel(turn) });
         }
+
         const active = turnId === options.activeTurnId || turn?.state === 'running';
+
         if (!turn || active) {
             const live = rowsForItems(conversation, options, children);
             rows.push(...(active ? withLiveThought(live, conversation) : live));
+
             if (active) {
                 rows.push({ kind: 'working', id: `working-${turnId}`, startedAt: turn?.createdAt ?? Date.now() });
             }
+
             continue;
         }
+
         // Steering splits the conversation inside a turn. Earlier responses keep their place above it.
         const lastUser = conversation.findLastIndex((item) => item.kind === 'user');
         rows.push(...rowsForItems(conversation.slice(0, lastUser + 1), options, children));
@@ -527,38 +622,46 @@ export function deriveTimelineRows(items: ChatItem[], options: TimelineOptions):
         const work = rowsForItems(rest, options, children);
         // The closing answer stays visible; the work after the last input folds behind the label.
         const finalAssistant = lastAssistantRow(work);
-        const before = finalAssistant ? work.slice(0, work.indexOf(finalAssistant)) : work;
+        const closing = finalAssistant ? work.indexOf(finalAssistant) : work.length;
+        const before = work.slice(0, closing);
+
         // Images remain a turn's visible result, and a workflow or a background subagent may still be running after its turn ends.
         const standing = before.filter(
             (row) => isImageRow(row) || (row.kind === 'workflow' && row.tool.state === 'running') || (row.kind === 'subagent' && row.item.status === 'running')
         );
-        const folded = before.filter((row) => !standing.includes(row));
+
+        const folded = before.length - standing.length;
         const expanded = options.expandedTurns.has(turnId);
-        if (folded.length > 0) {
+
+        if (folded > 0) {
             const tools = rest.filter(
                 (item): item is ChatToolItem => item.kind === 'tool' && parentOf(item) === null && handbackReportOf(item) === null && !isImageGeneration(item)
             );
+
             rows.push({
                 kind: 'turn-fold',
                 id: `fold-${turnId}`,
                 turn,
                 label: turnLabel(turn, chunk.items),
                 work: summarizeTurn(tools, options.commandLooks),
-                hiddenCount: folded.length,
+                hiddenCount: folded,
                 expanded
             });
         }
+
         rows.push(...(expanded ? before : standing));
         const changed = changedFilesRow(turn, conversation);
+
         if (changed) {
             rows.push(changed);
         }
-        if (finalAssistant) {
-            rows.push(...work.slice(work.indexOf(finalAssistant)));
-        }
+
+        rows.push(...work.slice(closing));
+
         if (options.forkedTurns?.has(turnId) === true) {
             rows.push({ kind: 'forks', id: `forks-${turnId}`, turnId });
         }
     }
+
     return rows;
 }

package/src/chat/logic/tools.ts

@@ -17,18 +17,24 @@ export function toolSummary(name: string, input: unknown): string {
     if (!isRecord(input)) {
         return '';
     }
+
     const known = toolEntry(name);
+
     if (known === undefined) {
         // A tool nobody wrote down, an MCP one above all, gets its best guess from the first string it was given.
         const first = Object.values(input).find((value) => typeof value === 'string');
+
         return typeof first === 'string' ? first : '';
     }
+
     for (const key of known.summary) {
         const value = str(input[key]);
+
         if (value !== null) {
             return value;
         }
     }
+
     return '';
 }
 
@@ -38,10 +44,13 @@ const PATH_KEYS = new Set(['file_path', 'notebook_path']);
 /* Whether the one line of a call is the path of a file, which a row cuts in the middle so the name stays. */
 export function toolSummaryIsPath(name: string, input: unknown): boolean {
     const known = toolEntry(name);
+
     if (known === undefined || !isRecord(input)) {
         return false;
     }
+
     const key = known.summary.find((candidate) => str(input[candidate]) !== null);
+
     return key !== undefined && PATH_KEYS.has(key);
 }
 
@@ -50,7 +59,9 @@ export function shellCommand(name: string, input: unknown): string | null {
     if (toolEntry(name)?.shell !== true || !isRecord(input)) {
         return null;
     }
+
     const command = str(input.command);
+
     return command === null || command.trim() === '' ? null : command;
 }
 
@@ -76,21 +87,27 @@ function valueText(value: unknown): string {
 export function toolCallLines(name: string, input: unknown): ToolCallLines {
     if (!isRecord(input)) {
         const text = input === null || input === undefined || input === '' ? null : valueText(input);
+
         return { command: null, args: [], text };
     }
+
     const command = shellCommand(name, input);
+
     const args = Object.entries(input)
         .filter(([key, value]) => value !== undefined && !(command !== null && SHELL_SHOWN.has(key)))
         .map(([key, value]) => [key, valueText(value)] as const);
+
     return { command, args, text: null };
 }
 
 /* A failed call's output with the exit code its tool put on the first line ("Exit code 1"), as Claude Code's shell does. */
 export function exitCodeOf(output: string): { code: number | null; rest: string } {
     const match = /^Exit code (-?\d+)[ \t]*(?:\r?\n|$)/.exec(output);
+
     if (match === null || Number(match[1]) === 0) {
         return { code: null, rest: output };
     }
+
     return { code: Number(match[1]), rest: output.slice(match[0].length) };
 }
 
@@ -104,7 +121,9 @@ export function hasToolBody(tool: ChatToolItem): boolean {
     if (hasFileChanges(tool) || hasOutput(tool.output)) {
         return true;
     }
+
     const lines = toolCallLines(tool.name, tool.input);
+
     return lines.command !== null || lines.args.length > 0 || lines.text !== null;
 }
 
@@ -116,11 +135,15 @@ export function readImagePath(name: string, input: unknown): string | null {
     if (toolEntry(name)?.readsImage !== true) {
         return null;
     }
+
     const path = isRecord(input) ? str(input.file_path) : null;
+
     if (path === null) {
         return null;
     }
+
     const lowered = path.toLowerCase();
+
     return IMAGE_SUFFIXES.some((suffix) => lowered.endsWith(suffix)) ? path : null;
 }
 
@@ -129,16 +152,21 @@ export function fileChanges(name: string, input: unknown): FileChange[] {
     if (!isRecord(input)) {
         return [];
     }
+
     const path = str(input.file_path) ?? '';
+
     if (name === 'Edit') {
         return [{ path, before: str(input.old_string) ?? '', after: str(input.new_string) ?? '' }];
     }
+
     if (name === 'Write') {
         return [{ path, before: '', after: str(input.content) ?? '' }];
     }
+
     if (name === 'MultiEdit' && Array.isArray(input.edits)) {
         return input.edits.filter(isRecord).map((edit) => ({ path, before: str(edit.old_string) ?? '', after: str(edit.new_string) ?? '' }));
     }
+
     return [];
 }
 
@@ -154,9 +182,11 @@ export function unifiedChanges(tool: ChatToolItem): ChatFileChange[] {
 /* The same, for the copy an approval carries so the person can read what they are approving. */
 export function approvalChanges(input: unknown): ChatFileChange[] {
     const changes = isRecord(input) ? input.changes : null;
+
     if (!Array.isArray(changes)) {
         return [];
     }
+
     return changes.filter(
         (change): change is ChatFileChange => isRecord(change) && typeof change.path === 'string' && typeof change.diff === 'string' && change.diff !== ''
     );

package/src/chat/logic/visual-height.ts

@@ -2,6 +2,7 @@ import { VISUAL_LIMITS, visualFrameHeight, type ChatVisual } from '@adecore/agen
 
 /* A frame before anything measured its page: room for a chart, never taller than the page may grow. */
 export const DEFAULT_HEIGHT_PX = 240;
+
 /* Plenty for the visuals of a long session; the oldest goes first. */
 const REMEMBERED_HEIGHTS = 500;
 // Stay within browser layout coordinates even if a page reports a bogus finite size.
@@ -28,11 +29,14 @@ export function visualContentHeight(height: number): number {
 
 export function initialVisualContentHeight(visual: Pick<ChatVisual, 'id' | 'heights'>, width: number): number {
     const cached = remembered.get(keyOf(visual.id, width));
+
     if (cached !== undefined) {
         return cached;
     }
+
     const below = visual.heights?.filter(([measured]) => measured <= width).sort((left, right) => right[0] - left[0])[0];
     const above = visual.heights?.filter(([measured]) => measured >= width).sort((left, right) => left[0] - right[0])[0];
+
     return below || above ? visualContentHeight(Math.max(below?.[1] ?? 0, above?.[1] ?? 0)) : DEFAULT_HEIGHT_PX;
 }
 
@@ -48,6 +52,7 @@ export function rememberVisualHeight(visualId: string, width: number, height: nu
     const key = keyOf(visualId, width);
     remembered.delete(key);
     remembered.set(key, height);
+
     if (remembered.size > REMEMBERED_HEIGHTS) {
         remembered.delete(remembered.keys().next().value!);
     }

package/src/chat/logic/visual-viewport.ts

@@ -5,5 +5,6 @@ export interface VisualViewportGeometry {
 
 export function visualViewportGeometry(contentHeight: number, availableHeight: number, top: number): VisualViewportGeometry {
     const height = Math.max(1, Math.min(contentHeight, availableHeight));
+
     return { height, top: Math.max(0, Math.min(-top, contentHeight - height)) };
 }

package/src/chat/logic/welcome.ts

@@ -3,11 +3,14 @@ export type DayPart = 'morning' | 'afternoon' | 'evening' | 'night';
 
 export function dayPartOf(now: Date): DayPart {
     const hour = now.getHours();
+
     if (hour < 5) {
         return 'night';
     }
+
     if (hour < 12) {
         return 'morning';
     }
+
     return hour < 18 ? 'afternoon' : 'evening';
 }