@adecore/agents-react 0.39.0 → 0.40.0

package/src/chat/logic/embedded-code.ts

@@ -10,6 +10,7 @@ export const SHELL_LANGUAGE = 'shellscript';
 
 // Past this a command is drawn without looking for code inside it; the scan is linear, the highlighting is not.
 export const EMBEDDED_CODE_LIMIT = 20_000;
+
 const MAX_DEPTH = 3;
 
 /* A stretch of a shell command, as offsets into it. */
@@ -113,6 +114,7 @@ const INTERPRETERS: Record<string, Interpreter> = {
 const WRAPPERS = new Set(['sudo', 'env', 'exec', 'nohup', 'time', 'command', 'nice']);
 // Tools that run a program of a project's environment as `<tool> run <program>`.
 const RUNNERS = new Set(['uv', 'poetry', 'pipenv']);
+
 // Where a heredoc written to a file goes, by the file's extension.
 const EXTENSIONS: Record<string, string> = {
     py: 'python',
@@ -143,6 +145,7 @@ const BLANKS = ' \t\r';
 /* The program a command name runs, as the table above knows it: `/usr/bin/python3.12` is `python`. */
 function programOf(word: string): string {
     const name = word.slice(word.lastIndexOf('/') + 1);
+
     return /^python\d*(\.\d+)?$/.test(name) ? 'python' : name;
 }
 
@@ -153,17 +156,21 @@ function parseCommands(source: string, from: number, to: number): SimpleCommand[
     const pending: { command: SimpleCommand; delimiter: string; strip: boolean; operator: Span }[] = [];
     // The start of the `2` of a `2>&1` just read, which the redirect after it begins at.
     let descriptorStart: number | null = null;
+
     const finish = (): void => {
         if (current.words.length > 0 || current.redirects.length > 0) {
             commands.push(current);
         }
+
         current = { words: [], redirects: [], heredocs: [] };
         descriptorStart = null;
     };
+
     const skipBlanks = (index: number): number => {
         while (index < to && BLANKS.includes(source[index]!)) {
             index++;
         }
+
         return index;
     };
 
@@ -173,12 +180,16 @@ function parseCommands(source: string, from: number, to: number): SimpleCommand[
         let quoted: Span | null = null;
         let parts = 0;
         let bare = true;
+
         while (index < to) {
             const char = source[index]!;
+
             if (BLANKS.includes(char) || char === '\n' || SEPARATORS.includes(char) || char === '<' || char === '>') {
                 break;
             }
+
             parts++;
+
             if (char === "'") {
                 const close = source.indexOf("'", index + 1);
                 const end = close === -1 || close >= to ? to : close;
@@ -188,6 +199,7 @@ function parseCommands(source: string, from: number, to: number): SimpleCommand[
                 index = Math.min(end + 1, to);
             } else if (char === '"') {
                 let end = index + 1;
+
                 while (end < to && source[end] !== '"') {
                     if (source[end] === '\\' && end + 1 < to && '$`"\\\n'.includes(source[end + 1]!)) {
                         text += source[end + 1];
@@ -197,6 +209,7 @@ function parseCommands(source: string, from: number, to: number): SimpleCommand[
                         end++;
                     }
                 }
+
                 quoted = { start: index + 1, end };
                 bare = false;
                 index = Math.min(end + 1, to);
@@ -213,38 +226,49 @@ function parseCommands(source: string, from: number, to: number): SimpleCommand[
                 index++;
             }
         }
+
         const end = Math.min(index, to);
         const body = bare ? { start, end } : parts === 1 && quoted !== null ? quoted : null;
+
         return { start, end, text, body };
     };
 
     const readHeredoc = (start: number, delimiter: string, strip: boolean): { body: Span; next: number } => {
         let index = start;
+
         while (index < to) {
             const newline = source.indexOf('\n', index);
             const lineEnd = newline === -1 || newline >= to ? to : newline;
             let line = source.slice(index, lineEnd).replace(/\r$/, '');
+
             if (strip) {
                 line = line.replace(/^\t+/, '');
             }
+
             if (line === delimiter) {
                 return { body: { start, end: index }, next: Math.min(lineEnd + 1, to) };
             }
+
             index = lineEnd + 1;
         }
+
         return { body: { start, end: to }, next: to };
     };
 
     let index = from;
+
     while (index < to) {
         const char = source[index]!;
+
         if (char === '\n') {
             index++;
+
             for (const heredoc of pending) {
                 const { body, next } = readHeredoc(index, heredoc.delimiter, heredoc.strip);
                 heredoc.command.heredocs.push({ ...heredoc.operator, body });
                 index = next;
             }
+
             pending.length = 0;
             finish();
         } else if (BLANKS.includes(char)) {
@@ -261,15 +285,19 @@ function parseCommands(source: string, from: number, to: number): SimpleCommand[
             index += 2;
             const strip = source[index] === '-';
             const word = readWord(skipBlanks(strip ? index + 1 : index));
+
             if (word.text !== '') {
                 pending.push({ command: current, delimiter: word.text, strip, operator: { start, end: word.end } });
             }
+
             index = word.end;
         } else if (char === '<' || char === '>' || (char === '&' && source[index + 1] === '>')) {
             let end = index + 1;
+
             while (end < to && '<>&|'.includes(source[end]!)) {
                 end++;
             }
+
             const op = source.slice(index, end);
             const target = readWord(skipBlanks(end));
             current.redirects.push({ start: descriptorStart ?? index, end: Math.max(target.end, end), op, target });
@@ -282,15 +310,19 @@ function parseCommands(source: string, from: number, to: number): SimpleCommand[
             const word = readWord(index);
             // The `2` of `2>&1` is a file descriptor, not an argument.
             const descriptor = /^\d+$/.test(word.text) && (source[word.end] === '>' || source[word.end] === '<');
+
             if (descriptor) {
                 descriptorStart = word.start;
             } else {
                 current.words.push(word);
             }
+
             index = Math.max(word.end, index + 1);
         }
     }
+
     finish();
+
     return commands;
 }
 
@@ -298,8 +330,10 @@ function parseCommands(source: string, from: number, to: number): SimpleCommand[
 function closingParen(source: string, open: number, to: number): number {
     let depth = 0;
     let quote: string | null = null;
+
     for (let index = open; index < to; index++) {
         const char = source[index]!;
+
         if (quote !== null) {
             if (char === quote) {
                 quote = null;
@@ -312,23 +346,28 @@ function closingParen(source: string, open: number, to: number): number {
             depth++;
         } else if (char === ')') {
             depth--;
+
             if (depth === 0) {
                 return index + 1;
             }
         }
     }
+
     return to;
 }
 
 /* The index of the word a command runs, past variable assignments, wrappers and runners; -1 for none. */
 function programIndex(words: readonly Word[]): number {
     let index = 0;
+
     while (index < words.length) {
         const text = words[index]!.text;
+
         if (/^[A-Za-z_][A-Za-z0-9_]*=/.test(text)) {
             index++;
         } else if (WRAPPERS.has(programOf(text))) {
             index++;
+
             while (index < words.length && words[index]!.text.startsWith('-')) {
                 index++;
             }
@@ -338,6 +377,7 @@ function programIndex(words: readonly Word[]): number {
             return index;
         }
     }
+
     return -1;
 }
 
@@ -348,49 +388,64 @@ function codeOf(command: SimpleCommand): EmbeddedCode[] {
     const program = at === -1 ? '' : programOf(command.words[at]!.text);
     const interpreter = INTERPRETERS[program];
     let readsFile = false;
+
     if (interpreter !== undefined) {
         let positional = 0;
+
         for (let index = at + 1; index < command.words.length; index++) {
             const word = command.words[index]!;
+
             if (word.text.startsWith('-') && word.text !== '-') {
                 if (interpreter.script(word.text)) {
                     const script = command.words[index + 1];
+
                     if (script?.body) {
                         found.push({ ...script.body, language: interpreter.language });
                     }
+
                     readsFile = true;
                     index++;
                 } else if (interpreter.takesValue?.has(word.text)) {
                     index++;
                 } else if (interpreter === PYTHON && word.text === '-m') {
                     readsFile = true;
+
                     break;
                 }
+
                 continue;
             }
+
             if (interpreter.client !== true) {
                 // A script file; whatever follows is its own arguments.
                 readsFile = word.text !== '-';
+
                 break;
             }
+
             if (positional === interpreter.positional && word.body !== null) {
                 found.push({ ...word.body, language: interpreter.language });
             }
+
             positional++;
         }
     }
+
     const heredocLanguage = interpreter !== undefined && (!readsFile || interpreter.client === true) ? interpreter.language : writtenLanguage(command, program);
+
     if (heredocLanguage !== null) {
         for (const { body } of command.heredocs) {
             found.push({ ...body, language: heredocLanguage });
         }
     }
+
     return found;
 }
 
 /* The language of the file a `cat > file` or `tee file` writes, by its extension; null when nothing says. */
 function writtenLanguage(command: SimpleCommand, program: string): string | null {
     const targets = command.redirects.filter(({ op }) => op === '>' || op === '>>' || op === '>|').map(({ target }) => target.text);
+
     if (program === 'tee') {
         targets.push(
             ...command.words
@@ -399,13 +454,16 @@ function writtenLanguage(command: SimpleCommand, program: string): string | null
                 .filter((text) => !text.startsWith('-'))
         );
     }
+
     for (const target of targets) {
         const dot = target.lastIndexOf('.');
         const language = dot === -1 ? undefined : EXTENSIONS[target.slice(dot + 1).toLowerCase()];
+
         if (language !== undefined) {
             return language;
         }
     }
+
     return null;
 }
 
@@ -415,7 +473,9 @@ function collect(source: string, from: number, to: number, depth: number, into:
             if (code.end <= code.start) {
                 continue;
             }
+
             into.push(code);
+
             if (code.language === SHELL_LANGUAGE && depth < MAX_DEPTH) {
                 collect(source, code.start, code.end, depth + 1, into);
             }
@@ -431,6 +491,7 @@ export function shellCommands(source: string): ShellSimpleCommand[] {
     return parseCommands(source, 0, source.length).map((command) => {
         const index = programIndex(command.words);
         const word = command.words[index];
+
         return {
             ...command,
             program: word === undefined ? null : { index, name: word.text.slice(word.text.lastIndexOf('/') + 1) }
@@ -449,7 +510,9 @@ export function embeddedCode(command: string): EmbeddedCode[] {
     if (command.length > EMBEDDED_CODE_LIMIT) {
         return [];
     }
+
     const found: EmbeddedCode[] = [];
     collect(command, 0, command.length, 0, found);
+
     return found.sort((left, right) => left.start - right.start || right.end - left.end);
 }

package/src/chat/logic/fork.ts

@@ -20,6 +20,7 @@ export interface ForkPoint {
 function turnsOf(items: Record<string, ChatItem>, order: readonly string[]): ChatTurnItem[] {
     return order.flatMap((id) => {
         const item = items[id];
+
         return item?.kind === 'turn' ? [item] : [];
     });
 }
@@ -32,15 +33,19 @@ export function forkRefusal(info: ChatInfo | null, turn: ChatItem | undefined):
     if (info === null || turn?.kind !== 'turn') {
         return i18next.t('agent-chat:fork.refusal.notInConversation');
     }
+
     if (!FORKABLE_PROVIDERS.has(info.provider)) {
         return i18next.t('agent-chat:fork.refusal.cliCannotFork');
     }
+
     if (info.agentSessionId === null) {
         return i18next.t('agent-chat:fork.refusal.noConversation');
     }
+
     if (turn.state === 'running' || info.activeTurnId !== null) {
         return i18next.t('agent-chat:fork.refusal.turnRunning');
     }
+
     return null;
 }
 
@@ -49,31 +54,37 @@ export function summaryRefusal(state: { busy: boolean; originalPresent: boolean
     if (!state.originalPresent) {
         return i18next.t('agent-chat:fork.refusal.originalGone');
     }
+
     if (state.busy) {
         return i18next.t('agent-chat:fork.refusal.turnRunning');
     }
+
     return null;
 }
 
 /* The forks this client knows of that went on after this turn of this chat, in the order it holds them. */
 export function forkIdsAfter(infos: Iterable<ChatInfo>, chatId: string, turnId: string): string[] {
     const ids: string[] = [];
+
     for (const info of infos) {
         if (info.forkOf?.chatId === chatId && info.forkOf.turnId === turnId) {
             ids.push(info.chatId);
         }
     }
+
     return ids;
 }
 
 /* The turns of this chat that at least one fork this client knows of went on after. */
 export function forkedTurnIds(infos: Iterable<ChatInfo>, chatId: string): Set<string> {
     const turns = new Set<string>();
+
     for (const info of infos) {
         if (info.forkOf?.chatId === chatId) {
             turns.add(info.forkOf.turnId);
         }
     }
+
     return turns;
 }
 
@@ -86,16 +97,20 @@ export function forkPointOf(items: Record<string, ChatItem>, order: readonly str
     const turns = turnsOf(items, order);
     const index = turns.findIndex((turn) => turn.id === turnId);
     const turn = turns[index];
+
     if (turn === undefined) {
         return null;
     }
+
     const asked = order.map((id) => items[id]).find((item) => item?.kind === 'user' && item.turnId === turnId);
     const text = asked?.kind === 'user' ? asked.text : (turn.label ?? '');
+
     const prompt =
         text
             .split('\n')
             .find((line) => line.trim() !== '')
             ?.trim() ?? null;
+
     return { turnId, number: index + 1, total: turns.length, counted: whole, last: index === turns.length - 1, prompt };
 }
 
@@ -106,10 +121,13 @@ export function forkPointLabel(point: ForkPoint, maxPrompt = 60): string {
         : point.counted
           ? i18next.t('agent-chat:fork.point.afterTurn', { number: point.number, total: point.total })
           : i18next.t('agent-chat:fork.point.afterThis');
+
     if (point.prompt === null) {
         return where;
     }
+
     const prompt = point.prompt.length > maxPrompt ? `${point.prompt.slice(0, maxPrompt - 1)}…` : point.prompt;
+
     return i18next.t('agent-chat:fork.point.about', { where, prompt });
 }
 
@@ -177,6 +195,7 @@ export function forkPayload(input: {
     const provider = cli !== undefined && cli.chosen.provider !== cli.original.provider ? cli.chosen.provider : null;
     const selection = cli !== undefined && (provider !== null || cli.chosen.selection.model !== cli.original.selection.model) ? cli.chosen.selection : null;
     const account = cli?.chosen.account !== undefined && (provider !== null || cli.chosen.account !== cli.original.account) ? cli.chosen.account : null;
+
     return {
         chatId: input.chatId,
         turnId: input.turnId,
@@ -192,11 +211,14 @@ export function forkPayload(input: {
 /* Why a branch cannot be the fork's, or null when it can. */
 export function branchRefusal(branch: string, taken: readonly string[]): string | null {
     const name = branch.trim();
+
     if (name === '') {
         return i18next.t('agent-chat:fork.branch.unnamed');
     }
+
     if (taken.includes(name)) {
         return i18next.t('agent-chat:fork.branch.taken');
     }
+
     return null;
 }

package/src/chat/logic/generated-image.ts

@@ -23,22 +23,29 @@ export function generatedImageView(tool: ChatToolItem): GeneratedImageView {
     if (tool.state === 'running') {
         return { state: 'generating' };
     }
+
     const parsed = GeneratedImageInputSchema.safeParse(tool.input);
     const input = parsed.success ? parsed.data : {};
     const output = tool.output?.trim() || null;
+
     if (tool.state === 'error' || input.attachment === undefined) {
         return { state: 'failed', failure: output === null && tool.state !== 'error' ? { kind: 'empty' } : { kind: 'provider', message: output } };
     }
+
     const attachment = input.attachment;
+
     if (attachment.size === 0) {
         return { state: 'failed', failure: { kind: 'empty' } };
     }
+
     if (!attachment.mime.startsWith('image/')) {
         return { state: 'failed', failure: { kind: 'not-image' } };
     }
+
     if (attachment.size > CHAT_ATTACHMENT_MAX_BYTES) {
         return { state: 'failed', failure: { kind: 'too-large', limit: CHAT_ATTACHMENT_MAX_BYTES } };
     }
+
     return { state: 'ready', attachment, prompt: input.revisedPrompt?.trim() || null, transparent: input.transparentBackground === true };
 }
 

package/src/chat/logic/goal.ts

@@ -13,21 +13,28 @@ export interface GoalView {
  */
 export function goalView(info: Pick<ChatInfo, 'goal' | 'activeTurnId'>, goals: ProviderCapabilities['goals'], canAct: boolean): GoalView | null {
     const goal = info.goal;
+
     if (goal === undefined) {
         return null;
     }
+
     if (!canAct || goals === undefined) {
         return { goal, actions: [] };
     }
+
     if (goals === 'command') {
         return { goal, actions: goal.status === 'complete' || info.activeTurnId !== null ? [] : ['clear'] };
     }
+
     const actions: ChatGoalAction[] = [];
+
     if (goal.status === 'active') {
         actions.push('pause');
     } else if (goal.status !== 'complete') {
         actions.push('resume');
     }
+
     actions.push('clear');
+
     return { goal, actions };
 }

package/src/chat/logic/handback.ts

@@ -5,6 +5,8 @@ export function handbackReportOf(item: ChatItem): string | null {
     if (item.kind !== 'tool' || item.name !== 'SubagentHandback' || typeof item.input !== 'object' || item.input === null) {
         return null;
     }
+
     const message = (item.input as { message?: unknown }).message;
+
     return typeof message === 'string' && message.trim() !== '' ? message : null;
 }

package/src/chat/logic/limit.ts

@@ -16,10 +16,13 @@ export interface LimitView {
  */
 export function limitView(info: Pick<ChatInfo, 'limit' | 'resumeAt' | 'activeTurnId'>, now: number): LimitView | null {
     const limit = info.limit;
+
     if (limit === undefined || info.activeTurnId !== null) {
         return null;
     }
+
     const resumes = info.resumeAt === undefined ? null : formatMoment(info.resumeAt, now);
+
     if (limit.kind === 'overload') {
         return {
             pill: resumes === null ? i18next.t('agent-chat:limit.overload.pill') : i18next.t('agent-chat:limit.overload.pillRetry', { time: resumes }),
@@ -27,7 +30,9 @@ export function limitView(info: Pick<ChatInfo, 'limit' | 'resumeAt' | 'activeTur
             detail: resumes === null ? i18next.t('agent-chat:limit.overload.sendAgain') : i18next.t('agent-chat:limit.overload.retries', { time: resumes })
         };
     }
+
     const title = i18next.t('agent-chat:limit.usage.title');
+
     if (resumes !== null) {
         return {
             pill: i18next.t('agent-chat:limit.usage.pillResumes', { time: resumes }),
@@ -35,13 +40,16 @@ export function limitView(info: Pick<ChatInfo, 'limit' | 'resumeAt' | 'activeTur
             detail: i18next.t('agent-chat:limit.usage.resumes', { time: resumes })
         };
     }
+
     if (limit.resetsAt !== undefined) {
         const resets = formatMoment(limit.resetsAt, now);
+
         return {
             pill: i18next.t('agent-chat:limit.usage.pillUntil', { time: resets }),
             title,
             detail: i18next.t('agent-chat:limit.usage.resets', { time: resets })
         };
     }
+
     return { pill: i18next.t('agent-chat:limit.usage.pill'), title, detail: null };
 }

package/src/chat/logic/picker-entries.ts

@@ -4,6 +4,7 @@ import { nameCollator } from '@adecore/ui/format';
 /* The providers in the order a picker lists them: the frontier labs, the rest, then the API providers, each by name. */
 export function inPickerOrder<T extends { kind: AgentKind; name: string }>(providers: readonly T[]): T[] {
     const groups = pickerGroupsOf(providers);
+
     return [...groups.frontier, ...groups.others, ...groups.api];
 }
 
@@ -33,6 +34,7 @@ export interface PickerCurrent {
 export type FavoritesOf = (kind: AgentKind) => ReadonlySet<string>;
 
 const NO_FAVORITES: FavoritesOf = () => new Set();
+
 const VENDOR_ORDER: Intl.CollatorOptions = { sensitivity: 'base' };
 const MODEL_ORDER: Intl.CollatorOptions = { sensitivity: 'base', numeric: true };
 
@@ -48,12 +50,15 @@ export function modelsByVendor(models: ModelInfo[]): ModelInfo[] {
     if (!models.some((model) => model.vendor !== undefined)) {
         return models;
     }
+
     const vendorOrder = nameCollator(VENDOR_ORDER).compare;
     const modelOrder = nameCollator(MODEL_ORDER).compare;
+
     return [...models].sort((a, b) => {
         if (a.vendor === undefined || b.vendor === undefined) {
             return a.vendor === b.vendor ? 0 : a.vendor === undefined ? 1 : -1;
         }
+
         return vendorOrder(a.vendor, b.vendor) || modelOrder(a.name, b.name);
     });
 }
@@ -63,6 +68,7 @@ export function favoritesFirst(models: ModelInfo[], favorites: ReadonlySet<strin
     if (favorites.size === 0) {
         return modelsByVendor(models);
     }
+
     return [...models.filter((model) => favorites.has(model.slug)), ...modelsByVendor(models.filter((model) => !favorites.has(model.slug)))];
 }
 
@@ -79,6 +85,7 @@ export function shortlistOf(
     if (models.length <= COMPACT_MODEL_LIMIT) {
         return null;
     }
+
     return favoritesFirst(
         models.filter((model) => model.isDefault || favorites.has(model.slug) || (current?.provider === kind && current.model === model.slug)),
         favorites
@@ -97,6 +104,7 @@ export function searchModels(
     favoritesOf: FavoritesOf = NO_FAVORITES
 ): Array<{ entry: ProviderInfo; models: ModelInfo[] }> {
     const needle = query.trim().toLowerCase();
+
     return providers
         .map((entry) => ({
             entry,
@@ -126,6 +134,7 @@ export function pickerEntriesOf(
 ): PickerEntry[] {
     const rowsOf = (entry: ProviderInfo, models: ModelInfo[]): PickerEntry[] =>
         favoritesFirst(models, favoritesOf(entry.kind)).map((model) => ({ kind: 'model', provider: entry, model }));
+
     if (query !== '') {
         return providers.flatMap((entry) =>
             rowsOf(
@@ -134,22 +143,25 @@ export function pickerEntriesOf(
             )
         );
     }
+
     const legacy = providers.flatMap((entry) =>
         entry.models.filter((model) => model.legacy).map((model) => ({ kind: 'model' as const, provider: entry, model }))
     );
+
     const live = providers.flatMap((entry): PickerEntry[] => {
         const models = entry.models.filter((model) => !model.legacy);
         const shortlist = shortlistOf(entry.kind, models, current, favoritesOf(entry.kind));
+
         if (shortlist === null) {
             return rowsOf(entry, models);
         }
+
         if (expanded.has(entry.kind)) {
             return [{ kind: 'all', provider: entry, count: models.length, open: true }, ...rowsOf(entry, models)];
         }
+
         return [...rowsOf(entry, shortlist), { kind: 'all', provider: entry, count: models.length, open: false }];
     });
-    if (legacy.length === 0) {
-        return live;
-    }
-    return legacyOpen ? [...live, { kind: 'legacy', count: legacy.length }, ...legacy] : [...live, { kind: 'legacy', count: legacy.length }];
+
+    return legacy.length === 0 ? live : [...live, { kind: 'legacy', count: legacy.length }, ...(legacyOpen ? legacy : [])];
 }