@adecore/agents-react 0.21.1 → 0.22.0

package/dist/chat/stash.js

@@ -23,6 +23,16 @@ function attachments(value) {
         size: typeof entry.size === 'number' ? entry.size : 0
     }));
 }
+function stashedQuote(value) {
+    if (!isRecord(value) || typeof value.text !== 'string' || typeof value.chatId !== 'string' || typeof value.itemId !== 'string') {
+        return undefined;
+    }
+    return { text: value.text, chatId: value.chatId, itemId: value.itemId };
+}
+function stashedQuoteField(value) {
+    const quote = stashedQuote(value);
+    return quote === undefined ? {} : { quote };
+}
 /* Only the fields we know today, so anything an older or a broken write left behind falls away here. */
 export function parseStash(raw) {
     if (raw === null) {
@@ -42,6 +52,7 @@ export function parseStash(raw) {
             mentions: strings(entry.mentions),
             skills: strings(entry.skills),
             attachments: attachments(entry.attachments),
+            ...stashedQuoteField(entry.quote),
             createdAt: typeof entry.createdAt === 'number' ? entry.createdAt : 0
         }))
             .slice(0, STASH_LIMIT);
@@ -54,14 +65,19 @@ export function parseStash(raw) {
 export function withStashed(prompts, entry) {
     return [entry, ...prompts].slice(0, STASH_LIMIT);
 }
-/* What a draft looks like on the shelf, its quote folded into the text; null when there is nothing worth putting there. */
-export function stashedFrom(draft, id, now) {
+/*
+ * What a draft looks like on the shelf; null when there is nothing worth putting there. A quote that
+ * knows its reply stays apart, since it leads back to that reply in `chatId`; any other is folded into the text.
+ */
+export function stashedFrom(draft, id, now, chatId) {
     if (isEmptyDraft(draft)) {
         return null;
     }
+    const kept = draft.quote !== '' && draft.quoteSource !== null;
     return {
         id,
-        text: withQuote(draft.quote, draft.text),
+        text: kept ? draft.text : withQuote(draft.quote, draft.text),
+        ...(kept ? { quote: { text: draft.quote, chatId, itemId: draft.quoteSource } } : {}),
         mentions: [...draft.mentions],
         skills: [...draft.skills],
         attachments: draft.attachments.map((attachment) => ({ name: attachment.name, mime: attachment.mime, size: uploadBytes(attachment) })),
@@ -69,17 +85,15 @@ 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 });
     storage.write(prompts);
 }
 /* Puts a draft on the shelf; false when the composer held nothing to put there. */
-export function stashDraft(draft) {
-    const entry = stashedFrom(draft, `stash-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, Date.now());
+export function stashDraft(draft, chatId) {
+    const entry = stashedFrom(draft, `stash-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, Date.now(), chatId);
     if (!entry) {
         return false;
     }

package/dist/chat/subagent-list.d.ts

@@ -7,11 +7,17 @@ export declare function taskIdOf(item: ChatSubagentItem): string | null;
 export declare function statusWordOf(item: ChatSubagentItem, task: SubagentTask | null): StatusWord;
 export type TaskRowState = StatusWord | 'waiting';
 export declare function taskRowStateOf(item: ChatSubagentItem, task: SubagentTask | null, child: ChatInfo | undefined): TaskRowState;
+export declare function progressOf(states: readonly TaskRowState[]): {
+    done: number;
+    total: number;
+    waiting: number;
+    active: number;
+};
 export declare function flyoutSubagents(order: readonly string[], structure: Readonly<Record<string, ChatItem>>): ChatSubagentItem[];
 export declare function summaryWordOf(words: readonly StatusWord[]): StatusWord;
 export declare function badgeCountOf(words: readonly StatusWord[]): number;
 export declare function entryTimeOf(item: ChatSubagentItem, task: SubagentTask | null, now: number): string;
-export type SubagentStop = 'task' | 'mark';
+export type SubagentStop = 'task' | 'native' | 'mark';
 export declare function stopOf(item: ChatSubagentItem, turnRunning: boolean): SubagentStop | null;
 export declare function stopLabel(stop: SubagentStop): string;
 export type ComposerStop = 'turn' | 'turn-and-subagents';

package/dist/chat/subagent-list.js

@@ -36,6 +36,15 @@ export function taskRowStateOf(item, task, child) {
     }
     return word;
 }
+/* How far delegated work is: what settled as done, what still runs or waits, and how many of those wait on a person. */
+export function progressOf(states) {
+    return {
+        done: states.filter((state) => state === 'done').length,
+        total: states.length,
+        waiting: states.filter((state) => state === 'waiting').length,
+        active: states.filter((state) => state === 'running' || state === 'paused' || state === 'waiting').length
+    };
+}
 /*
  * What the flyout over the composer lists: every sub-agent still at work, and the ones that settled
  * since the last message, so a finished batch stays until the next message is sent. That includes an
@@ -93,10 +102,13 @@ export function stopOf(item, turnRunning) {
     if (item.origin === 'ruimte') {
         return item.childId === undefined ? null : 'task';
     }
+    if (item.native?.agentId) {
+        return 'native';
+    }
     return turnRunning ? null : 'mark';
 }
 export function stopLabel(stop) {
-    return stop === 'task' ? i18next.t('agent-chat:subagents.stop.task') : i18next.t('agent-chat:subagents.stop.mark');
+    return i18next.t(`agent-chat:subagents.stop.${stop}`);
 }
 export function composerStopOf(shiftKey) {
     return shiftKey ? 'turn-and-subagents' : 'turn';

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.d.ts

@@ -11,8 +11,12 @@ export declare function scrollTimelineToEnd(chatId: string, behavior?: ScrollBeh
 export declare function pageTimeline(chatId: string, direction: -1 | 1): boolean;
 export declare function registerMessageStepper(key: string, step: (direction: -1 | 1) => boolean): () => void;
 export declare function stepTimelineMessage(key: string, direction: -1 | 1): boolean;
-export declare function registerItemJumper(key: string, jump: (itemId: string) => void): () => void;
-export declare function jumpToTimelineItem(key: string, itemId: string): boolean;
+export interface ItemJumpOptions {
+    flash?: boolean;
+    onMissing?(): void;
+}
+export declare function registerItemJumper(key: string, jump: (itemId: string, options: ItemJumpOptions) => void): () => void;
+export declare function jumpToTimelineItem(key: string, itemId: string, options?: ItemJumpOptions): boolean;
 export type TurnTarget = 'prompt' | 'changes';
 type TurnJump = (turnId: string, target: TurnTarget) => void;
 export declare function registerTurnJumper(key: string, jump: TurnJump): () => void;

package/dist/chat/timeline-scroll.js

@@ -1,6 +1,11 @@
 // 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;
+// How long a jump asked before its thread registered stays up for that thread.
+const PENDING_JUMP_TTL_MS = 10_000;
 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 +19,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 +75,56 @@ 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);
+            const pending = waiting.get(key);
+            if (pending !== undefined) {
+                waiting.delete(key);
+                // A jump nobody picked up for long is not what the person wants any more.
+                if (Date.now() - pending.at <= PENDING_JUMP_TTL_MS) {
+                    jump(pending.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, at: Date.now() });
+                return false;
+            }
+            jump(target);
+            return true;
         }
     };
 }
+const itemJumps = waitingJumps();
+export function registerItemJumper(key, jump) {
+    return itemJumps.register(key, ({ itemId, options }) => jump(itemId, options));
+}
 /* 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;
+export function jumpToTimelineItem(key, itemId, options = {}) {
+    return itemJumps.jump(key, { itemId, options });
 }
-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/ChatActivity.js

@@ -2,15 +2,15 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 import { useMemo } from 'react';
 import clsx from 'clsx';
 import { useTranslation } from 'react-i18next';
-import { Activity, Square, SquareTerminal } from 'lucide-react';
+import { Activity, MessageCircleQuestionMark, Square, SquareTerminal } from 'lucide-react';
 import { backgroundCounts } from '../activity.js';
-import { badgeCountOf, entryTimeOf, flyoutSubagents, statusWordOf, subagentTitle, summaryWordOf, taskIdOf } from '../subagent-list.js';
+import { badgeCountOf, entryTimeOf, flyoutSubagents, progressOf, statusWordOf, subagentTitle, summaryWordOf, taskIdOf, taskRowStateOf } from '../subagent-list.js';
 import { useSubagentSupport } from '../subagent-support.js';
 import { canOpenSubagent, crumbOf, openFromMain, useSubagentTrail } from '../subagent-view.js';
 import { SubagentStopButton } from './SubagentStopButton.js';
 import { formatElapsedShort } from '@adecore/ui/format';
 import { Icon, IconButton, Popover, Surface, useNow } from '@adecore/ui';
-import { useChatRow } from '../../state/chats.js';
+import { useChatRow, useChats } from '../../state/chats.js';
 import { chatHost } from '../../host.js';
 import { useChatScope } from '../../scope.js';
 import { useChatActions } from '../actions.js';
@@ -24,8 +24,14 @@ export function ChatActivity({ chatId }) {
     const order = useChatRow(chatId, (row) => row?.order) ?? NO_ITEMS;
     const structure = useChatRow(chatId, (row) => row?.structure);
     const subagents = useMemo(() => (structure === undefined ? [] : flyoutSubagents(order, structure)), [order, structure]);
-    const { id } = useChatScope();
+    const { id, keyOf } = useChatScope();
     const tasks = chatHost().tasks.useTasks(id);
+    const statuses = useChats((s) => s.statusByKey);
+    const progress = useMemo(() => progressOf(subagents.map((item) => {
+        const taskId = taskIdOf(item);
+        const child = item.childId === undefined ? undefined : statuses[keyOf(item.childId)]?.info;
+        return taskRowStateOf(item, taskId === null ? null : (tasks?.[taskId] ?? null), child);
+    })), [subagents, tasks, statuses, keyOf]);
     const words = useMemo(() => subagents.map((item) => {
         const taskId = taskIdOf(item);
         return statusWordOf(item, taskId === null ? null : (tasks?.[taskId] ?? null));
@@ -36,8 +42,14 @@ export function ChatActivity({ chatId }) {
     }
     const { shells, monitors } = backgroundCounts(background);
     const Slot = chatHost().SubagentSlot;
+    const counting = progress.active > 0 && progress.total > 1;
+    const label = counting
+        ? [t('activity.progress', { done: progress.done, total: progress.total }), progress.waiting > 0 && t('activity.needsYou', { count: progress.waiting })]
+            .filter(Boolean)
+            .join(', ')
+        : t('activity.subagents', { count: badgeCountOf(words) });
     return (_jsxs("div", { className: "mb-3 flex flex-wrap items-center gap-2", children: [subagents.length > 0 &&
-                (Slot === null ? (_jsx(Flyout, { icon: _jsx(StatusIcon, { word: summaryWordOf(words) }), label: t('activity.subagents', { count: badgeCountOf(words) }), heading: t('activity.subagents', { count: subagents.length }), children: _jsx(SubagentRows, { chatId: chatId, items: subagents }) })) : (_jsx(Slot, { chatId: chatId, items: subagents }))), background.length > 0 && (_jsx(Flyout, { icon: _jsx(Icon, { icon: shells > 0 ? SquareTerminal : Activity, size: 14 }), label: [shells > 0 && t('activity.shells', { count: shells }), monitors > 0 && t('activity.monitors', { count: monitors })]
+                (Slot === null ? (_jsx(Flyout, { icon: progress.waiting > 0 ? (_jsx(Icon, { icon: MessageCircleQuestionMark, size: 14, className: "shrink-0 text-status-needs-you" })) : (_jsx(StatusIcon, { word: summaryWordOf(words) })), label: label, heading: t('activity.subagents', { count: subagents.length }), children: _jsx(SubagentRows, { chatId: chatId, items: subagents }) })) : (_jsx(Slot, { chatId: chatId, items: subagents }))), background.length > 0 && (_jsx(Flyout, { icon: _jsx(Icon, { icon: shells > 0 ? SquareTerminal : Activity, size: 14 }), label: [shells > 0 && t('activity.shells', { count: shells }), monitors > 0 && t('activity.monitors', { count: monitors })]
                     .filter(Boolean)
                     .join(' · '), children: _jsx(BackgroundTaskRows, { chatId: chatId, tasks: background }) }))] }));
 }
@@ -47,7 +59,7 @@ export function StatusIcon({ word }) {
 }
 /* A chip that opens a list over it, headed by what the chip says unless the list counts more than the chip does. */
 function Flyout({ icon, label, heading = label, children }) {
-    return (_jsxs(Popover.Root, { children: [_jsxs(Surface, { render: _jsx(Popover.Trigger, {}), className: "pointer-events-auto inline-flex h-7.5 items-center gap-1.5 rounded-full px-3 text-xs text-text-muted hover:text-text", children: [icon, label] }), _jsxs(Popover.Popup, { side: "top", className: "w-80", children: [_jsx("div", { className: "px-2.5 pt-1.5 pb-1 text-xs text-text-faint", children: heading }), children] })] }));
+    return (_jsxs(Popover.Root, { children: [_jsxs(Surface, { render: _jsx(Popover.Trigger, {}), className: "pointer-events-auto inline-flex h-7.5 items-center gap-1.5 rounded-full px-3 text-xs text-text-muted tabular-nums hover:text-text", children: [icon, label] }), _jsxs(Popover.Popup, { side: "top", className: "w-80", children: [_jsx("div", { className: "px-2.5 pt-1.5 pb-1 text-xs text-text-faint", children: heading }), children] })] }));
 }
 /* One line of a flyout; with `onOpen` the line leads somewhere and closes the flyout on the way. */
 function ActivityRow({ icon, title, detail, time, onOpen, children }) {
@@ -62,12 +74,14 @@ function SubagentRows({ chatId, items }) {
 }
 function SubagentEntry({ chatId, item, now }) {
     const { t } = useTranslation('agent-chat');
-    const { id } = useChatScope();
+    const { id, keyOf } = useChatScope();
     const refused = useSubagentSupport((s) => s.unsupported[id] === true);
     const task = chatHost().tasks.useTask(id, taskIdOf(item));
     const { show } = useSubagentTrail(chatId);
+    const child = useChats((s) => (item.childId === undefined ? undefined : s.statusByKey[keyOf(item.childId)]?.info));
     const word = statusWordOf(item, task);
-    return (_jsx(ActivityRow, { icon: _jsx(StatusIcon, { word: word }), title: _jsxs(_Fragment, { children: [subagentTitle(item), _jsxs("span", { className: "sr-only", children: [", ", t(`common.status.${word}`)] })] }), time: entryTimeOf(item, task, now), onOpen: canOpenSubagent(item, refused) ? () => show(openFromMain(crumbOf(item))) : undefined, children: _jsx(SubagentStopButton, { chatId: chatId, item: item, className: "mr-1.5" }) }));
+    const state = taskRowStateOf(item, task, child);
+    return (_jsx(ActivityRow, { icon: _jsx(StatusIcon, { word: word }), title: _jsxs(_Fragment, { children: [subagentTitle(item), _jsxs("span", { className: "sr-only", children: [", ", state === 'waiting' ? t('rows.task.waiting') : t(`common.status.${word}`)] })] }), time: entryTimeOf(item, task, now), onOpen: canOpenSubagent(item, refused) ? () => show(openFromMain(crumbOf(item))) : undefined, children: _jsx(SubagentStopButton, { chatId: chatId, item: item, className: "mr-1.5" }) }));
 }
 /* Only drawn while the flyout is open, so the clock ticks for nobody otherwise. */
 function BackgroundTaskRows({ chatId, tasks }) {

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');