@adecore/agents-react 0.21.1 → 0.21.2

package/dist/agents/status-look.js

@@ -1,8 +1,7 @@
 import { CircleCheck, CircleSlash, CircleX, Hourglass, LoaderCircle } from 'lucide-react';
 /*
- * One state, one mark: an entry in the sub-agent flyout, a task on its node (`TaskMark`), what finished
- * in the toolbar (`StatusSummary`) and work in progress in a toast. A spinner stops under reduced
- * motion with every other animation (`styles.css`).
+ * One state, one mark, wherever work is drawn: a sub-agent entry, a task, a summary or a toast. A
+ * spinner stops under reduced motion with every other animation.
  */
 const LOOKS = {
     running: { icon: LoaderCircle, tone: 'text-status-running', spins: true },

package/dist/chat/chat-client.d.ts

@@ -26,9 +26,9 @@ export declare class ChatClient {
     private readonly mounted;
     private readonly unsubscribe;
     private readonly earlier;
+    private readonly inspections;
     private preferences;
     constructor(transport: ChatTransport, sink: ChatSink, providers?: ProviderSink | null);
-    private readonly inspections;
     inspect(chatId: string): Promise<ChatAttachResult>;
     open(chatId: string, options: ChatOpenOptions): Promise<boolean>;
     retarget(chatId: string, provider: AgentKind, selection: ModelSelection): Promise<void>;

package/dist/chat/chat-client.js

@@ -15,6 +15,7 @@ export class ChatClient {
     mounted = new MountedRegistry();
     unsubscribe = [];
     earlier = new Map();
+    inspections = new Map();
     preferences = null;
     constructor(transport, sink, providers = null) {
         this.transport = transport;
@@ -34,7 +35,6 @@ export class ChatClient {
             void this.loadStatuses();
         }
     }
-    inspections = new Map();
     inspect(chatId) {
         const pending = this.inspections.get(chatId);
         if (pending) {
@@ -277,7 +277,7 @@ export class ChatClient {
             this.sendPreferences();
             void this.loadProviders();
             void this.loadStatuses();
-            void this.mounted.reattachAll((chatId) => this.attach(chatId).then(() => undefined));
+            void this.mounted.reattachAll((chatId) => this.attach(chatId));
             return;
         }
         this.mounted.detachAll();

package/dist/chat/drafts.js

@@ -4,12 +4,6 @@ import { persistedJson } from './persisted-json.js';
 const storageKey = () => chatStorageKey('drafts');
 export const EMPTY_DRAFT = { text: '', mentions: [], skills: [], chats: [], attachments: [], quote: '' };
 const storage = persistedJson(storageKey, (raw) => (raw ? JSON.parse(raw) : {}), {}, () => chatStorageLegacyKeys('drafts'));
-function readAll() {
-    return storage.read();
-}
-function store(drafts) {
-    return storage.write(drafts);
-}
 export function isEmptyDraft(draft) {
     return draft.text.trim() === '' && draft.attachments.length === 0 && draft.quote === '';
 }
@@ -17,7 +11,7 @@ export function isEmptyDraft(draft) {
  * Which chats hold an unsent prompt, for a dot beside them in a list of chats. The drafts themselves
  * stay in storage: a node that is not on screen has no composer, and this is all anyone else needs.
  */
-export const useDrafts = createChatStore(() => ({ ids: [] }), (store) => store.setState({ ids: Object.keys(readAll()) }));
+export const useDrafts = createChatStore(() => ({ ids: [] }), (store) => store.setState({ ids: Object.keys(storage.read()) }));
 export function useHasDraft(chatId) {
     return useDrafts((s) => s.ids.includes(chatId));
 }
@@ -30,7 +24,7 @@ function trackDraft(chatId, held) {
 }
 /* An unsent prompt per chat node, kept across reloads so a half-written message is never lost. */
 export function readDraft(chatId) {
-    const record = readAll()[chatId];
+    const record = storage.read()[chatId];
     return record
         ? {
             text: record.text,
@@ -43,11 +37,11 @@ export function readDraft(chatId) {
         : EMPTY_DRAFT;
 }
 export function writeDraft(chatId, draft) {
-    const drafts = readAll();
+    const drafts = storage.read();
     trackDraft(chatId, !isEmptyDraft(draft));
     if (isEmptyDraft(draft)) {
         delete drafts[chatId];
-        store(drafts);
+        storage.write(drafts);
         return;
     }
     drafts[chatId] = {
@@ -58,12 +52,12 @@ export function writeDraft(chatId, draft) {
         attachments: draft.attachments,
         quote: draft.quote
     };
-    if (store(drafts)) {
+    if (storage.write(drafts)) {
         return;
     }
     // A file can outgrow the storage quota; the text is the part worth keeping then.
     drafts[chatId] = { text: draft.text, mentions: draft.mentions, skills: draft.skills, chats: draft.chats, quote: draft.quote };
-    store(drafts);
+    storage.write(drafts);
 }
 /* Text handed to a draft from outside the composer goes under what was already typed, never over it. */
 export function joinDraftText(current, added) {

package/dist/chat/logic/ansi.js

@@ -144,7 +144,7 @@ function styleOf(state) {
     }
     return style;
 }
-export function parseAnsi(text, options = {}) {
+function styledTokens(text) {
     const tokens = [];
     let state = {};
     let position = 0;
@@ -160,6 +160,10 @@ export function parseAnsi(text, options = {}) {
     if (position < text.length) {
         tokens.push({ content: text.slice(position), style: styleOf(state) });
     }
+    return tokens;
+}
+export function parseAnsi(text, options = {}) {
+    const tokens = styledTokens(text);
     const plain = tokens.map((token) => token.content).join('');
     let start = 0;
     let end = plain.length;

package/dist/chat/logic/fork.js

@@ -121,20 +121,19 @@ export function forkShapes(origin) {
     return origin === 'view' ? ['view'] : ['node', 'view'];
 }
 export function forkPayload(input) {
+    const { cli, worktree } = 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,
         title: input.title,
         ...(input.shape === 'view' ? { asView: true } : {}),
-        ...(input.cli && input.cli.chosen.provider !== input.cli.original.provider ? { provider: input.cli.chosen.provider } : {}),
-        ...(input.cli && (input.cli.chosen.provider !== input.cli.original.provider || input.cli.chosen.selection.model !== input.cli.original.selection.model)
-            ? { selection: input.cli.chosen.selection }
-            : {}),
-        ...(input.cli?.chosen.account !== undefined &&
-            (input.cli.chosen.provider !== input.cli.original.provider || input.cli.chosen.account !== input.cli.original.account)
-            ? { account: input.cli.chosen.account }
-            : {}),
-        ...(input.worktree ? { worktree: { branch: input.worktree.branch }, ...(input.worktree.filesAfterTurn ? { filesAfterTurn: true } : {}) } : {})
+        ...(provider === null ? {} : { provider }),
+        ...(selection === null ? {} : { selection }),
+        ...(account === null ? {} : { account }),
+        ...(worktree ? { worktree: { branch: worktree.branch }, ...(worktree.filesAfterTurn ? { filesAfterTurn: true } : {}) } : {})
     };
 }
 /* Why a branch cannot be the fork's, or null when it can. */

package/dist/chat/logic/limit.js

@@ -17,18 +17,21 @@ export function limitView(info, now) {
             detail: resumes === null ? i18next.t('agent-chat:limit.overload.sendAgain') : i18next.t('agent-chat:limit.overload.retries', { time: resumes })
         };
     }
-    const resets = limit.resetsAt === undefined ? null : formatMoment(limit.resetsAt, now);
-    return {
-        pill: resumes !== null
-            ? i18next.t('agent-chat:limit.usage.pillResumes', { time: resumes })
-            : resets !== null
-                ? i18next.t('agent-chat:limit.usage.pillUntil', { time: resets })
-                : i18next.t('agent-chat:limit.usage.pill'),
-        title: i18next.t('agent-chat:limit.usage.title'),
-        detail: resumes !== null
-            ? i18next.t('agent-chat:limit.usage.resumes', { time: resumes })
-            : resets !== null
-                ? i18next.t('agent-chat:limit.usage.resets', { time: resets })
-                : null
-    };
+    const title = i18next.t('agent-chat:limit.usage.title');
+    if (resumes !== null) {
+        return {
+            pill: i18next.t('agent-chat:limit.usage.pillResumes', { time: resumes }),
+            title,
+            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/dist/chat/logic/resume-compaction.js

@@ -6,18 +6,9 @@ export const RESUME_COMPACTION_TOKENS = 100_000;
 /* The longest prompt cache Claude keeps is an hour, so past this the whole thread is read again anyway. */
 export const RESUME_COMPACTION_IDLE_MS = 70 * 60_000;
 function lastTurn(items) {
-    for (let i = items.length - 1; i >= 0; i--) {
-        const item = items[i];
-        if (item.kind === 'turn') {
-            return item;
-        }
-    }
-    return null;
+    return items.findLast((item) => item.kind === 'turn') ?? null;
 }
-/*
- * Whether to offer compacting before the next message. The caller passes `now`, so this stays pure
- * and the test needs no clock.
- */
+/* Whether to offer compacting before the next message. */
 export function resumeCompactionOffer({ info, compaction, items, dismissedTurnId, now }) {
     if (compaction === undefined || compaction === 'none') {
         return null;

package/dist/chat/logic/scrubber.js

@@ -76,20 +76,7 @@ export function tickOfRow(ticks, rowIndex) {
     if (ticks.length === 0) {
         return null;
     }
-    let low = 0;
-    let high = ticks.length - 1;
-    let found = 0;
-    while (low <= high) {
-        const middle = (low + high) >> 1;
-        if (ticks[middle].rowIndex <= rowIndex) {
-            found = middle;
-            low = middle + 1;
-        }
-        else {
-            high = middle - 1;
-        }
-    }
-    return found;
+    return Math.max(0, lastIndexAtOrBelow(ticks.length, (index) => ticks[index].rowIndex, rowIndex));
 }
 /* Per tick, whether any of the rows has a find hit in its stretch. */
 export function ticksWithHits(ticks, hitRows) {
@@ -146,14 +133,14 @@ export function tickWidth(kind, distanceFromPointer) {
     }
     return kind === 'wake' ? WIDTH_WAKE_PX : WIDTH_PERSON_PX;
 }
-/* The last index whose start lies at or above a line, or -1. The starts only grow. */
-function lastAtOrAbove(starts, line) {
+/* The last index whose value is at most `limit`, or -1. The values only grow. */
+function lastIndexAtOrBelow(length, valueAt, limit) {
     let low = 0;
-    let high = starts.length - 1;
+    let high = length - 1;
     let found = -1;
     while (low <= high) {
         const middle = (low + high) >> 1;
-        if (starts[middle] <= line) {
+        if (valueAt(middle) <= limit) {
             found = middle;
             low = middle + 1;
         }
@@ -163,6 +150,10 @@ function lastAtOrAbove(starts, line) {
     }
     return found;
 }
+/* The last index whose start lies at or above a line, or -1. */
+function lastAtOrAbove(starts, line) {
+    return lastIndexAtOrBelow(starts.length, (index) => starts[index], line);
+}
 /*
  * The messages on screen. A message counts from its own start to the start of the next one, so the
  * question whose answer fills the screen is in view even after it scrolled out at the top.

package/dist/chat/logic/timeline.js

@@ -21,10 +21,9 @@ export function summarizeGroup(tools) {
     if (only !== null && toolEntry(only)?.grouped === true) {
         return i18next.t(`agent-chat:group.tools.${only}`, { count: tools.length });
     }
-    /* A run that only touches files says so once, whether it took one tool or three, and counts the
-       files rather than the calls: three edits to one file are one file edited. */
+    // Counts the files rather than the calls: three edits to one file are one file edited.
     if (tools.every((tool) => isFileChange(tool.name))) {
-        const paths = new Set(tools.map((tool) => tool.input?.file_path ?? tool.id));
+        const paths = new Set(tools.map(editedPath));
         return i18next.t('agent-chat:group.edited', { count: paths.size });
     }
     if (only !== null) {
@@ -32,6 +31,9 @@ export function summarizeGroup(tools) {
     }
     return i18next.t('agent-chat:group.toolCalls', { count: tools.length });
 }
+function editedPath(tool) {
+    return tool.input?.file_path ?? tool.id;
+}
 /*
  * What a folded turn did, a sentence per kind of call in the order it first came: "Read 11 files",
  * "Searched 2 patterns". Every file change reads as one sentence, and calls without a sentence of
@@ -44,7 +46,7 @@ export function summarizeTurn(tools) {
     let other = 0;
     for (const tool of tools) {
         if (isFileChange(tool.name)) {
-            edited.add(tool.input?.file_path ?? tool.id);
+            edited.add(editedPath(tool));
             counts.set('agent-chat:group.edited', edited.size);
         }
         else if (toolEntry(tool.name)?.grouped === true) {
@@ -265,11 +267,8 @@ function lastAssistantRow(rows) {
     }
     return null;
 }
-/* The whole thread as rows; items without a turn (older records) are shown as they are. */
-export function deriveTimelineRows(items, options) {
-    const rows = [];
-    const children = groupChildren(items);
-    // Items are grouped by turn, in order of first appearance; runs of turnless items keep their place.
+/* Items grouped by turn, in order of first appearance; runs of turnless items keep their place. */
+function chunksByTurn(items) {
     const chunks = [];
     const byTurn = new Map();
     for (const item of items) {
@@ -291,7 +290,13 @@ export function deriveTimelineRows(items, options) {
         }
         bucket.push(item);
     }
-    for (const chunk of chunks) {
+    return chunks;
+}
+/* The whole thread as rows; items without a turn (older records) are shown as they are. */
+export function deriveTimelineRows(items, options) {
+    const rows = [];
+    const children = groupChildren(items);
+    for (const chunk of chunksByTurn(items)) {
         if (chunk.turnId === null) {
             rows.push(...rowsForItems(chunk.items, options, children));
             continue;

package/dist/chat/logic/tool-catalog.js

@@ -10,10 +10,9 @@ function entry(icon, summary, rest = {}) {
     };
 }
 /*
- * The icon, the summary line, the group sentence and the file-changing flag of every tool the thread
- * has a word for, in one table, because they used to sit in four and a name added to one of them was
- * missing from the rest. A name that is not here still draws, reads and groups; it falls back to the
- * wrench and to the first string of its input.
+ * Every tool the thread has a word for, in one table so a new name is never missing from a lookup. A
+ * name that is not here still draws, reads and groups; it falls back to the wrench and to the first
+ * string of its input.
  */
 export const TOOL_CATALOG = {
     Read: entry(Eye, ['file_path'], { readsImage: true }),

package/dist/chat/mentions.js

@@ -1,5 +1,7 @@
-/* What a file dragged out of an app's own list of files carries: the paths, space separated, relative
-   to the folder. The composer takes it next to the image files it already accepts. */
+/*
+ * What a file dragged out of an app's own list of files carries: the paths, space separated, relative
+ * to the folder. The composer takes it next to the image files it already accepts.
+ */
 export const MENTION_DRAG_TYPE = 'application/x-adecore-mention';
 export const LEGACY_MENTION_DRAG_TYPE = 'application/x-ruimte-mention';
 export const MENTION_DRAG_TYPES = [MENTION_DRAG_TYPE, LEGACY_MENTION_DRAG_TYPE];
@@ -110,10 +112,7 @@ export function presentMentions(text, chosen) {
 export function presentSkills(text, chosen) {
     return present(text, '$', chosen);
 }
-/*
- * The characters a segment stands for, sigil included. Joined, the segments spell the text they
- * were cut from.
- */
+/* The characters a segment stands for, sigil included; joined, the segments spell the text they were cut from. */
 export function chipText(segment) {
     if (segment.kind === 'mention') {
         return `@${segment.path}`;

package/dist/chat/runtime-modes.js

@@ -1,10 +1,8 @@
 import i18next from 'i18next';
 import { RuntimeModeSchema } from '@adecore/agent-contracts';
 /*
- * The runtime modes in the order they are offered, shared by the composer's mode picker, the
- * settings dialog and the agent menus. That order is the schema's, which the host reads as the
- * rank from narrowest to widest. Only the ids live here: the words are in `modes.<id>` of the `chat`
- * namespace, read when a surface draws one rather than when this module loads.
+ * The runtime modes in the order they are offered: the schema's, which the host reads as the rank
+ * from narrowest to widest. Their words are read when a surface draws one, not when this module loads.
  */
 export const RUNTIME_MODES = RuntimeModeSchema.options;
 export function runtimeModeLabel(mode) {

package/dist/chat/stash.js

@@ -69,9 +69,7 @@ export function stashedFrom(draft, id, now) {
     };
 }
 const storage = persistedJson(storageKey, parseStash, [], () => chatStorageLegacyKeys('stash'));
-/*
- * Prompts put aside for later can move to another chat, so the shelf is shared across chats.
- */
+/* Prompts put aside for later can move to another chat, so the shelf is shared across chats. */
 export const useStash = createChatStore(() => ({ prompts: [] }), (store) => store.setState({ prompts: storage.read() }));
 function write(prompts) {
     useStash.setState({ prompts });

package/dist/chat/thumbnails.js

@@ -30,10 +30,9 @@ function dataUrlOf(blob) {
     });
 }
 /*
- * A still of the middle of an image, decoded once. The composer used to draw the full data URL in a
- * 56 px box, which a browser decodes again for every paint, so a tall screenshot made typing stutter.
- * An animated image gives its first frame. Whatever cannot be decoded this way (an SVG, a browser
- * without `OffscreenCanvas`) falls back to the image itself, which is what it was before.
+ * A still of the middle of an image, decoded once: a browser decodes a full data URL again on every
+ * paint, so a tall screenshot made typing stutter. An animated image gives its first frame; what
+ * cannot be decoded this way (an SVG, a browser without `OffscreenCanvas`) falls back to the image.
  */
 async function makeThumbnail(upload) {
     try {

package/dist/chat/timeline-scroll.js

@@ -1,6 +1,9 @@
 // A page is a screen minus a little, so the line you were reading is still on it after the jump.
 const PAGE_OVERLAP = 0.9;
 const scrollers = new Map();
+/* The timeline owns following; the composer subscribes here to show its jump-to-end button. */
+const ends = new Map();
+const listeners = new Set();
 /* The timeline hands its scroller over so the composer, which never sees it, can page through it. */
 export function registerTimeline(chatId, element, follow, coveredHeight) {
     if (element === null) {
@@ -14,9 +17,6 @@ export function registerTimeline(chatId, element, follow, coveredHeight) {
         }
     };
 }
-/* The timeline owns following; the composer subscribes here to show its jump-to-end button. */
-const ends = new Map();
-const listeners = new Set();
 export function setTimelineAtEnd(chatId, atEnd) {
     if (ends.get(chatId) === atEnd) {
         return;
@@ -73,59 +73,53 @@ export function stepTimelineMessage(key, direction) {
     return steppers.get(key)?.(direction) ?? false;
 }
 /*
- * A jump to one message of a chat, asked from outside its thread (the chat's menu). A thread that is
- * not on screen yet gets it when it registers, since the menu may have to show the chat first.
- * Keyed with the scope's `keyOf`, like the steppers.
+ * Jumps asked from outside a thread (the chat's menu, a card that names a turn), keyed with the
+ * scope's `keyOf` like the steppers. A thread that is not on screen yet gets its jump when it
+ * registers, since the asker may have to show the chat first.
  */
-const jumpers = new Map();
-const waitingJumps = new Map();
-export function registerItemJumper(key, jump) {
-    jumpers.set(key, jump);
-    const waiting = waitingJumps.get(key);
-    if (waiting !== undefined) {
-        waitingJumps.delete(key);
-        jump(waiting);
-    }
-    return () => {
-        if (jumpers.get(key) === jump) {
-            jumpers.delete(key);
+function waitingJumps() {
+    const jumpers = new Map();
+    const waiting = new Map();
+    return {
+        register(key, jump) {
+            jumpers.set(key, jump);
+            if (waiting.has(key)) {
+                const target = waiting.get(key);
+                waiting.delete(key);
+                jump(target);
+            }
+            return () => {
+                if (jumpers.get(key) === jump) {
+                    jumpers.delete(key);
+                }
+            };
+        },
+        jump(key, target) {
+            const jump = jumpers.get(key);
+            if (jump === undefined) {
+                waiting.set(key, target);
+                return false;
+            }
+            jump(target);
+            return true;
         }
     };
 }
+const itemJumps = waitingJumps();
+export function registerItemJumper(key, jump) {
+    return itemJumps.register(key, jump);
+}
 /* False when that chat has no thread on screen; the jump then waits for the next one that registers. */
 export function jumpToTimelineItem(key, itemId) {
-    const jump = jumpers.get(key);
-    if (jump === undefined) {
-        waitingJumps.set(key, itemId);
-        return false;
-    }
-    jump(itemId);
-    return true;
+    return itemJumps.jump(key, itemId);
 }
-const turnJumpers = new Map();
-const waitingTurnJumps = new Map();
+const turnJumps = waitingJumps();
 export function registerTurnJumper(key, jump) {
-    turnJumpers.set(key, jump);
-    const waiting = waitingTurnJumps.get(key);
-    if (waiting !== undefined) {
-        waitingTurnJumps.delete(key);
-        jump(waiting.turnId, waiting.target);
-    }
-    return () => {
-        if (turnJumpers.get(key) === jump) {
-            turnJumpers.delete(key);
-        }
-    };
+    return turnJumps.register(key, ({ turnId, target }) => jump(turnId, target));
 }
 /* False when that chat has no thread on screen; the jump then waits for the next one that registers. */
 export function jumpToTimelineTurn(key, turnId, target) {
-    const jump = turnJumpers.get(key);
-    if (jump === undefined) {
-        waitingTurnJumps.set(key, { turnId, target });
-        return false;
-    }
-    jump(turnId, target);
-    return true;
+    return turnJumps.jump(key, { turnId, target });
 }
 /* How near the top, in screens, the page before is asked for, so it is there before a reader reaches the edge. */
 const EARLIER_SCREENS = 1.5;

package/dist/chat/ui/BookmarkSubmenu.js

@@ -9,11 +9,7 @@ import { chatHost } from '../../host.js';
 import { useChatScope } from '../../scope.js';
 import { useChatRow } from '../../state/chats.js';
 import { Icon, Menu } from '@adecore/ui';
-/*
- * "Bookmarks" in the menu of a chat node or a chat view: the chat's bookmarks in the order of the
- * thread, each a jump to its message, with rename and remove on the row. A chat without bookmarks
- * draws nothing.
- */
+/* A chat's bookmarks in thread order, each a jump to its message with rename and remove; nothing without bookmarks. */
 export function BookmarkSubmenu({ chatId }) {
     const { t } = useTranslation('agent-chat');
     const scope = useChatScope();

package/dist/chat/ui/CodeBlock.js

@@ -102,9 +102,8 @@ const CodeLine = memo(function CodeLine({ tokens }) {
 });
 /*
  * A fenced block, highlighted a line at a time. Until shiki and the grammar are there it holds its
- * place invisibly in the same shape, so there is never a frame of bare code that turns colored. A
- * fence that is still open is tokenized as it grows, and the same component carries on once it
- * closes, so closing it does not draw it again.
+ * place invisibly, so bare code never turns colored. An open fence is tokenized as it grows, and
+ * closing it does not draw it again.
  */
 export function CodeBlock({ code, lang, actions }) {
     const { t } = useTranslation('agent-chat');