@adecore/agents-react 0.21.1 → 0.22.0

package/src/chat/chat-client.ts

@@ -4,6 +4,7 @@ import type {
     ChatAttachResult,
     ChatBookmark,
     ChatPreferencesPayload,
+    ChatQuoteSource,
     ChatSkill,
     ChatVisual,
     ModelSelection,
@@ -35,6 +36,8 @@ export interface ChatSendExtras {
     skills?: string[];
     /* Chats of the project picked with `@`; only their ids travel, the agent reads them itself. */
     chats?: string[];
+    /* The reply a quote at the head of the text was taken from. */
+    quoteSource?: ChatQuoteSource;
     attachments?: ChatAttachmentUpload[];
 }
 
@@ -63,6 +66,7 @@ export class ChatClient {
     private readonly mounted = new MountedRegistry<Mounted>();
     private readonly unsubscribe: Array<() => void> = [];
     private readonly earlier = new Map<string, Promise<void>>();
+    private readonly inspections = new Map<string, Promise<ChatAttachResult>>();
     private preferences: ChatPreferencesPayload | null = null;
 
     constructor(transport: ChatTransport, sink: ChatSink, providers: ProviderSink | null = null) {
@@ -89,8 +93,6 @@ export class ChatClient {
         }
     }
 
-    private readonly inspections = new Map<string, Promise<ChatAttachResult>>();
-
     inspect(chatId: string): Promise<ChatAttachResult> {
         const pending = this.inspections.get(chatId);
         if (pending) {
@@ -171,9 +173,11 @@ export class ChatClient {
         return this.transport.request('chat.send', {
             chatId,
             text,
+            delivery: extras.delivery,
             mentions: extras.mentions,
             skills: extras.skills,
             chats: extras.chats,
+            quoteSource: extras.quoteSource,
             attachments: extras.attachments
         });
     }
@@ -347,7 +351,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/src/chat/drafts.ts

@@ -14,12 +14,22 @@ export interface ChatDraft {
     attachments: ChatAttachmentUpload[];
     /* A piece of an answer that goes above the text as a blockquote; empty for none. */
     quote: string;
+    /* The reply the quote was taken from; null when the quote names none. */
+    quoteSource: string | null;
 }
 
-export const EMPTY_DRAFT: ChatDraft = { text: '', mentions: [], skills: [], chats: [], attachments: [], quote: '' };
+export const EMPTY_DRAFT: ChatDraft = { text: '', mentions: [], skills: [], chats: [], attachments: [], quote: '', quoteSource: null };
 
 // Older records only had text; the rest is filled in on read.
-type DraftRecord = { text: string; mentions?: string[]; skills?: string[]; chats?: string[]; attachments?: ChatAttachmentUpload[]; quote?: string };
+type DraftRecord = {
+    text: string;
+    mentions?: string[];
+    skills?: string[];
+    chats?: string[];
+    attachments?: ChatAttachmentUpload[];
+    quote?: string;
+    quoteSource?: string;
+};
 
 const storage = persistedJson<Record<string, DraftRecord>>(
     storageKey,
@@ -28,14 +38,6 @@ const storage = persistedJson<Record<string, DraftRecord>>(
     () => chatStorageLegacyKeys('drafts')
 );
 
-function readAll(): Record<string, DraftRecord> {
-    return storage.read();
-}
-
-function store(drafts: Record<string, DraftRecord>): boolean {
-    return storage.write(drafts);
-}
-
 export function isEmptyDraft(draft: ChatDraft): boolean {
     return draft.text.trim() === '' && draft.attachments.length === 0 && draft.quote === '';
 }
@@ -46,7 +48,7 @@ export function isEmptyDraft(draft: ChatDraft): boolean {
  */
 export const useDrafts = createChatStore<{ ids: string[] }>(
     () => ({ ids: [] }),
-    (store) => store.setState({ ids: Object.keys(readAll()) })
+    (store) => store.setState({ ids: Object.keys(storage.read()) })
 );
 
 export function useHasDraft(chatId: string): boolean {
@@ -63,7 +65,7 @@ function trackDraft(chatId: string, held: boolean): void {
 
 /* An unsent prompt per chat node, kept across reloads so a half-written message is never lost. */
 export function readDraft(chatId: string): ChatDraft {
-    const record = readAll()[chatId];
+    const record = storage.read()[chatId];
     return record
         ? {
               text: record.text,
@@ -71,17 +73,18 @@ export function readDraft(chatId: string): ChatDraft {
               skills: record.skills ?? [],
               chats: record.chats ?? [],
               attachments: record.attachments ?? [],
-              quote: record.quote ?? ''
+              quote: record.quote ?? '',
+              quoteSource: record.quoteSource ?? null
           }
         : EMPTY_DRAFT;
 }
 
 export function writeDraft(chatId: string, draft: ChatDraft): void {
-    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] = {
@@ -90,14 +93,22 @@ export function writeDraft(chatId: string, draft: ChatDraft): void {
         skills: draft.skills,
         chats: draft.chats,
         attachments: draft.attachments,
-        quote: draft.quote
+        quote: draft.quote,
+        ...(draft.quoteSource === null ? {} : { quoteSource: draft.quoteSource })
     };
-    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);
+    drafts[chatId] = {
+        text: draft.text,
+        mentions: draft.mentions,
+        skills: draft.skills,
+        chats: draft.chats,
+        quote: draft.quote,
+        ...(draft.quoteSource === null ? {} : { quoteSource: draft.quoteSource })
+    };
+    storage.write(drafts);
 }
 
 /* Text handed to a draft from outside the composer goes under what was already typed, never over it. */
@@ -116,7 +127,7 @@ function union(first: readonly string[], second: readonly string[]): string[] {
  */
 export function takeBackIntoDraft(
     current: ChatDraft,
-    taken: Omit<ChatDraft, 'quote'>
+    taken: Omit<ChatDraft, 'quote' | 'quoteSource'>
 ): { draft: ChatDraft; rejected: Array<{ name: string; reason: string }> } {
     const checked = checkAttachmentLimits(
         current.attachments.length,
@@ -130,7 +141,8 @@ export function takeBackIntoDraft(
             skills: union(taken.skills, current.skills),
             chats: union(taken.chats, current.chats),
             attachments: [...checked.accepted.map((entry) => entry.upload), ...current.attachments],
-            quote: current.quote
+            quote: current.quote,
+            quoteSource: current.quoteSource
         },
         rejected: checked.rejected
     };

package/src/chat/logic/ansi.ts

@@ -164,7 +164,7 @@ function styleOf(state: AnsiState): CSSProperties {
     return style;
 }
 
-export function parseAnsi(text: string, options: { limit?: number; tailLines?: number } = {}): { tokens: AnsiToken[]; omitted: number } {
+function styledTokens(text: string): AnsiToken[] {
     const tokens: AnsiToken[] = [];
     let state: AnsiState = {};
     let position = 0;
@@ -180,7 +180,11 @@ export function parseAnsi(text: string, options: { limit?: number; tailLines?: n
     if (position < text.length) {
         tokens.push({ content: text.slice(position), style: styleOf(state) });
     }
+    return tokens;
+}
 
+export function parseAnsi(text: string, options: { limit?: number; tailLines?: number } = {}): { tokens: AnsiToken[]; omitted: number } {
+    const tokens = styledTokens(text);
     const plain = tokens.map((token) => token.content).join('');
     let start = 0;
     let end = plain.length;

package/src/chat/logic/fork.ts

@@ -172,20 +172,19 @@ export function forkPayload(input: {
     worktree?: ForkWorktreeChoice | null;
     cli?: { original: ForkCliChoice; chosen: ForkCliChoice };
 }): ChatForkPayload {
+    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 } : {}) } : {})
     };
 }
 

package/src/chat/logic/limit.ts

@@ -27,20 +27,21 @@ 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 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/src/chat/logic/picker-entries.ts

@@ -0,0 +1,25 @@
+import type { ModelInfo, ProviderInfo } from '@adecore/agent-contracts';
+
+/* A model row, or the one row that folds the legacy models open. Both take a turn in the arrow keys. */
+export type PickerEntry = { kind: 'model'; provider: ProviderInfo; model: ModelInfo } | { kind: 'legacy'; count: number };
+
+function matches(model: ModelInfo, query: string): boolean {
+    return model.name.toLowerCase().includes(query) || model.slug.toLowerCase().includes(query);
+}
+
+/*
+ * The rows of the model list. A model an old CLI cannot run is a row like any other, so a search for
+ * only that model still finds the row that explains why it cannot be picked.
+ */
+export function pickerEntriesOf(providers: readonly ProviderInfo[], query: string, legacyOpen: boolean): PickerEntry[] {
+    const rows = providers.flatMap((entry) => entry.models.map((model) => ({ kind: 'model' as const, provider: entry, model })));
+    if (query !== '') {
+        return rows.filter((row) => matches(row.model, query));
+    }
+    const live = rows.filter((row) => !row.model.legacy);
+    const legacy = rows.filter((row) => row.model.legacy);
+    if (legacy.length === 0) {
+        return live;
+    }
+    return legacyOpen ? [...live, { kind: 'legacy', count: legacy.length }, ...legacy] : [...live, { kind: 'legacy', count: legacy.length }];
+}

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

@@ -16,19 +16,10 @@ export interface ResumeCompactionOffer {
 }
 
 function lastTurn(items: readonly ChatItem[]): Extract<ChatItem, { kind: 'turn' }> | null {
-    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 is Extract<ChatItem, { kind: 'turn' }> => 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,

package/src/chat/logic/scrubber.ts

@@ -127,19 +127,10 @@ export function tickOfRow(ticks: readonly ScrubberTick[], rowIndex: number): num
     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. */
@@ -199,14 +190,14 @@ export function tickWidth(kind: TickKind, distanceFromPointer: number | null): n
     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: readonly number[], line: number): number {
+/* The last index whose value is at most `limit`, or -1. The values only grow. */
+function lastIndexAtOrBelow(length: number, valueAt: (index: number) => number, limit: number): number {
     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;
         } else {
@@ -216,6 +207,11 @@ function lastAtOrAbove(starts: readonly number[], line: number): number {
     return found;
 }
 
+/* The last index whose start lies at or above a line, or -1. */
+function lastAtOrAbove(starts: readonly number[], line: number): number {
+    return lastIndexAtOrBelow(starts.length, (index) => starts[index]!, line);
+}
+
 export interface ReadingPosition {
     /* Where each message's row starts in the thread, in the virtualizer's measurements. */
     starts: readonly number[];

package/src/chat/logic/timeline.ts

@@ -52,7 +52,7 @@ export type TimelineRow =
     | { kind: 'question'; id: string; item: ChatQuestionItem }
     | { kind: 'note'; id: string; level: 'info' | 'warning' | 'error'; text: string; from?: string }
     | { kind: 'compaction'; id: string; preTokens: number | null }
-    | { kind: 'changed-files'; id: string; turnId: string; tools: ChatToolItem[]; diff: ChatCheckpointDiff | null; checkpoint: boolean }
+    | { kind: 'changed-files'; id: string; turnId: string; tools: ChatToolItem[]; diff: ChatCheckpointDiff | null; checkpoint: boolean; baseMoved?: BaseMoved }
     | { kind: 'turn-fold'; id: string; turn: ChatTurnItem; label: string; work: string[]; hiddenCount: number; expanded: boolean }
     | { kind: 'forks'; id: string; turnId: string }
     | { kind: 'working'; id: string; startedAt: number }
@@ -88,10 +88,9 @@ export function summarizeGroup(tools: ChatToolItem[]): string {
     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 as { file_path?: string })?.file_path ?? tool.id));
+        const paths = new Set(tools.map(editedPath));
         return i18next.t('agent-chat:group.edited', { count: paths.size });
     }
     if (only !== null) {
@@ -100,6 +99,10 @@ export function summarizeGroup(tools: ChatToolItem[]): string {
     return i18next.t('agent-chat:group.toolCalls', { count: tools.length });
 }
 
+function editedPath(tool: ChatToolItem): string {
+    return (tool.input as { file_path?: string })?.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
@@ -112,7 +115,7 @@ export function summarizeTurn(tools: readonly ChatToolItem[]): string[] {
     let other = 0;
     for (const tool of tools) {
         if (isFileChange(tool.name)) {
-            edited.add((tool.input as { file_path?: string })?.file_path ?? tool.id);
+            edited.add(editedPath(tool));
             counts.set('agent-chat:group.edited', edited.size);
         } else if (toolEntry(tool.name)?.grouped === true) {
             const key = `agent-chat:group.tools.${tool.name}`;
@@ -319,6 +322,12 @@ function rowsForItems(items: ChatItem[], options: TimelineOptions, children: Map
     return rows;
 }
 
+/* The branch the turn started on was not the one it ended on, so its diff also holds what came in with the move. */
+export interface BaseMoved {
+    from: string;
+    to: string;
+}
+
 /* The card of a settled turn: the checkpoint diff when the host took one, else what the tool calls carry. */
 function changedFilesRow(turn: ChatTurnItem, items: ChatItem[]): TimelineRow | null {
     const edits = items.filter(
@@ -329,7 +338,16 @@ function changedFilesRow(turn: ChatTurnItem, items: ChatItem[]): TimelineRow | n
     if (empty) {
         return null;
     }
-    return { kind: 'changed-files', id: `files-${turn.id}`, turnId: turn.id, tools: edits, diff, checkpoint: turn.checkpoint !== undefined };
+    const moved = turn.checkpointHead !== undefined && turn.checkpointHeadAfter !== undefined && turn.checkpointHead !== turn.checkpointHeadAfter;
+    return {
+        kind: 'changed-files',
+        id: `files-${turn.id}`,
+        turnId: turn.id,
+        tools: edits,
+        diff,
+        checkpoint: turn.checkpoint !== undefined,
+        ...(moved ? { baseMoved: { from: turn.checkpointHead!, to: turn.checkpointHeadAfter! } } : {})
+    };
 }
 
 function lastAssistantRow(rows: TimelineRow[]): TimelineRow | null {
@@ -345,12 +363,14 @@ function lastAssistantRow(rows: TimelineRow[]): TimelineRow | null {
     return null;
 }
 
-/* The whole thread as rows; items without a turn (older records) are shown as they are. */
-export function deriveTimelineRows(items: ChatItem[], options: TimelineOptions): TimelineRow[] {
-    const rows: TimelineRow[] = [];
-    const children = groupChildren(items);
-    // Items are grouped by turn, in order of first appearance; runs of turnless items keep their place.
-    const chunks: Array<{ turnId: string | null; items: ChatItem[] }> = [];
+interface TurnChunk {
+    turnId: string | null;
+    items: ChatItem[];
+}
+
+/* Items grouped by turn, in order of first appearance; runs of turnless items keep their place. */
+function chunksByTurn(items: ChatItem[]): TurnChunk[] {
+    const chunks: TurnChunk[] = [];
     const byTurn = new Map<string, ChatItem[]>();
     for (const item of items) {
         if (item.turnId === null) {
@@ -370,8 +390,14 @@ export function deriveTimelineRows(items: ChatItem[], options: TimelineOptions):
         }
         bucket.push(item);
     }
+    return chunks;
+}
 
-    for (const chunk of chunks) {
+/* The whole thread as rows; items without a turn (older records) are shown as they are. */
+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;

package/src/chat/logic/tool-catalog.ts

@@ -6,8 +6,10 @@ export interface ToolEntry {
     icon: LucideIcon;
     /* The input keys that hold the one line saying what the call is about, best first. */
     summary: readonly string[];
-    /* Whether a run of calls of this name reads as a sentence of its own (`agent-chat:group.tools.<name>`).
-       One that changes files without a sentence falls to `agent-chat:group.edited`, which counts files rather than calls. */
+    /*
+     * Whether a run of calls of this name reads as a sentence of its own (`agent-chat:group.tools.<name>`).
+     * One that changes files without a sentence falls to `agent-chat:group.edited`, which counts files.
+     */
     grouped: boolean;
     /* Whether the call writes to a file, which is what a mixed run of calls is named after. */
     changesFiles: boolean;
@@ -27,10 +29,9 @@ function entry(icon: LucideIcon, summary: readonly string[], rest: Partial<ToolE
 }
 
 /*
- * 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: Record<string, ToolEntry> = {
     Read: entry(Eye, ['file_path'], { readsImage: true }),

package/src/chat/mentions.ts

@@ -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] as const;
@@ -145,10 +147,7 @@ export function presentSkills(text: string, chosen: string[]): string[] {
     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: ChipSegment): string {
     if (segment.kind === 'mention') {
         return `@${segment.path}`;

package/src/chat/prompt-hold.ts

@@ -0,0 +1,27 @@
+/* How long a person must stop typing before a waiting prompt card takes the composer's place. */
+export const PROMPT_HOLD_PAUSE_MS = 2000;
+
+export interface HoldInput {
+    /* When the last change to the draft was made; null when none was since the hold last lifted. */
+    typedAt: number | null;
+    /* An IME composition is under way, which can run for any length without a change. */
+    composing: boolean;
+}
+
+export type HoldRelease = 'pause' | 'send' | 'blur' | 'show';
+
+/* A card waits while the person is composing, or typed less than the pause ago. */
+export function holdsPrompt(input: HoldInput, now: number): boolean {
+    if (input.composing) {
+        return true;
+    }
+    return input.typedAt !== null && now - input.typedAt < PROMPT_HOLD_PAUSE_MS;
+}
+
+/* The milliseconds until the hold lifts by itself; null when it holds until something else lifts it, or does not hold. */
+export function holdLiftsIn(input: HoldInput, now: number): number | null {
+    if (input.composing || input.typedAt === null) {
+        return null;
+    }
+    return Math.max(0, input.typedAt + PROMPT_HOLD_PAUSE_MS - now);
+}

package/src/chat/quote.ts

@@ -24,3 +24,23 @@ export function withQuote(quote: string, message: string): string {
         .join('\n');
     return message === '' ? block : `${block}\n\n${message}`;
 }
+
+/*
+ * The inverse of `withQuote`: the quote a message opens with and what follows it. Null when the text
+ * does not open with a blockquote that ends on a blank line or the end of the text.
+ */
+export function splitQuote(text: string): { quote: string; rest: string } | null {
+    const lines = text.split('\n');
+    let end = 0;
+    while (end < lines.length && (lines[end] === '>' || lines[end]!.startsWith('> '))) {
+        end += 1;
+    }
+    if (end === 0 || (end < lines.length && lines[end] !== '')) {
+        return null;
+    }
+    const quote = lines
+        .slice(0, end)
+        .map((line) => line.slice(2))
+        .join('\n');
+    return { quote, rest: lines.slice(end + 1).join('\n') };
+}

package/src/chat/runtime-modes.ts

@@ -2,10 +2,8 @@ import i18next from 'i18next';
 import { RuntimeModeSchema, type RuntimeMode } 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: readonly RuntimeMode[] = RuntimeModeSchema.options;