@adecore/agents-react 0.21.1 → 0.22.0

package/dist/agents/model-requirement.d.ts

@@ -0,0 +1,6 @@
+import type { ModelInfo, ProviderInfo } from '@adecore/agent-contracts';
+export interface ModelRequirement {
+    cli: string;
+    minVersion: string;
+}
+export declare function modelRequirementOf(model: ModelInfo, provider: ProviderInfo, reported: ReadonlySet<string>): ModelRequirement | null;

package/dist/agents/model-requirement.js

@@ -0,0 +1,26 @@
+function partsOf(version, strict) {
+    const found = (strict ? /^(\d+)\.(\d+)(?:\.(\d+))?$/ : /(\d+)\.(\d+)\.(\d+)/).exec(version);
+    return found === null ? null : [Number(found[1]), Number(found[2]), Number(found[3] ?? 0)];
+}
+/* Whether the model's reported name is this model: its slug, the slug with a suffix such as `[1m]`. */
+function isReported(slug, reported) {
+    return [...reported].some((name) => name === slug || name.startsWith(`${slug}[`));
+}
+/*
+ * What a model asks of the CLI that is too old for it, or null when nothing blocks it: no minimum is
+ * known, the CLI's version is not a readable x.y.z (so an unknown version invents no requirement), the
+ * CLI is new enough, or a chat of this provider already reported running the model.
+ */
+export function modelRequirementOf(model, provider, reported) {
+    const minimum = model.minCliVersion === undefined ? null : partsOf(model.minCliVersion, true);
+    const installed = provider.version === null ? null : partsOf(provider.version, false);
+    if (minimum === null || installed === null || isReported(model.slug, reported)) {
+        return null;
+    }
+    for (let i = 0; i < 3; i++) {
+        if (installed[i] !== minimum[i]) {
+            return (installed[i] ?? 0) > (minimum[i] ?? 0) ? null : { cli: provider.name, minVersion: model.minCliVersion ?? '' };
+        }
+    }
+    return null;
+}

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

@@ -1,4 +1,4 @@
-import type { AgentKind, ChatAttachmentUpload, ChatAttachResult, ChatBookmark, ChatPreferencesPayload, ChatSkill, ChatVisual, ModelSelection, ProviderInfo, RuntimeMode } from '@adecore/agent-contracts';
+import type { AgentKind, ChatAttachmentUpload, ChatAttachResult, ChatBookmark, ChatPreferencesPayload, ChatQuoteSource, ChatSkill, ChatVisual, ModelSelection, ProviderInfo, RuntimeMode } from '@adecore/agent-contracts';
 import type { ChatSink } from '../state/chats.js';
 import { type ChatTransport } from '../transport.js';
 interface ChatOpenOptions {
@@ -14,6 +14,7 @@ export interface ChatSendExtras {
     mentions?: string[];
     skills?: string[];
     chats?: string[];
+    quoteSource?: ChatQuoteSource;
     attachments?: ChatAttachmentUpload[];
 }
 interface ProviderSink {
@@ -26,9 +27,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) {
@@ -113,9 +113,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
         });
     }
@@ -277,7 +279,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.d.ts

@@ -6,6 +6,7 @@ export interface ChatDraft {
     chats: string[];
     attachments: ChatAttachmentUpload[];
     quote: string;
+    quoteSource: string | null;
 }
 export declare const EMPTY_DRAFT: ChatDraft;
 export declare function isEmptyDraft(draft: ChatDraft): boolean;
@@ -16,7 +17,7 @@ export declare function useHasDraft(chatId: string): boolean;
 export declare function readDraft(chatId: string): ChatDraft;
 export declare function writeDraft(chatId: string, draft: ChatDraft): void;
 export declare function joinDraftText(current: string, added: string): string;
-export declare function takeBackIntoDraft(current: ChatDraft, taken: Omit<ChatDraft, 'quote'>): {
+export declare function takeBackIntoDraft(current: ChatDraft, taken: Omit<ChatDraft, 'quote' | 'quoteSource'>): {
     draft: ChatDraft;
     rejected: Array<{
         name: string;

package/dist/chat/drafts.js

@@ -2,14 +2,8 @@ import { chatStorageKey, chatStorageLegacyKeys, createChatStore } from '../stora
 import { checkAttachmentLimits, uploadBytes } from './attachments.js';
 import { persistedJson } from './persisted-json.js';
 const storageKey = () => chatStorageKey('drafts');
-export const EMPTY_DRAFT = { text: '', mentions: [], skills: [], chats: [], attachments: [], quote: '' };
+export const EMPTY_DRAFT = { text: '', mentions: [], skills: [], chats: [], attachments: [], quote: '', quoteSource: null };
 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,
@@ -38,16 +32,17 @@ export function readDraft(chatId) {
             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, 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] = {
@@ -56,14 +51,22 @@ export function writeDraft(chatId, draft) {
         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. */
 export function joinDraftText(current, added) {
@@ -86,7 +89,8 @@ export function takeBackIntoDraft(current, taken) {
             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/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/picker-entries.d.ts

@@ -0,0 +1,10 @@
+import type { ModelInfo, ProviderInfo } from '@adecore/agent-contracts';
+export type PickerEntry = {
+    kind: 'model';
+    provider: ProviderInfo;
+    model: ModelInfo;
+} | {
+    kind: 'legacy';
+    count: number;
+};
+export declare function pickerEntriesOf(providers: readonly ProviderInfo[], query: string, legacyOpen: boolean): PickerEntry[];

package/dist/chat/logic/picker-entries.js

@@ -0,0 +1,19 @@
+function matches(model, query) {
+    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, query, legacyOpen) {
+    const rows = providers.flatMap((entry) => entry.models.map((model) => ({ kind: 'model', 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/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.d.ts

@@ -74,6 +74,7 @@ export type TimelineRow = {
     tools: ChatToolItem[];
     diff: ChatCheckpointDiff | null;
     checkpoint: boolean;
+    baseMoved?: BaseMoved;
 } | {
     kind: 'turn-fold';
     id: string;
@@ -115,5 +116,9 @@ export declare function findSubagentBranch(rows: readonly TimelineRow[], toolUse
     index: number;
     branch: SubagentBranch;
 } | null;
+export interface BaseMoved {
+    from: string;
+    to: string;
+}
 export declare function deriveTimelineRows(items: ChatItem[], options: TimelineOptions): TimelineRow[];
 export {};

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) {
@@ -251,7 +253,16 @@ function changedFilesRow(turn, items) {
     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) {
     for (let i = rows.length - 1; i >= 0; i--) {
@@ -265,11 +276,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 +299,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/prompt-hold.d.ts

@@ -0,0 +1,8 @@
+export declare const PROMPT_HOLD_PAUSE_MS = 2000;
+export interface HoldInput {
+    typedAt: number | null;
+    composing: boolean;
+}
+export type HoldRelease = 'pause' | 'send' | 'blur' | 'show';
+export declare function holdsPrompt(input: HoldInput, now: number): boolean;
+export declare function holdLiftsIn(input: HoldInput, now: number): number | null;

package/dist/chat/prompt-hold.js

@@ -0,0 +1,16 @@
+/* How long a person must stop typing before a waiting prompt card takes the composer's place. */
+export const PROMPT_HOLD_PAUSE_MS = 2000;
+/* A card waits while the person is composing, or typed less than the pause ago. */
+export function holdsPrompt(input, now) {
+    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, now) {
+    if (input.composing || input.typedAt === null) {
+        return null;
+    }
+    return Math.max(0, input.typedAt + PROMPT_HOLD_PAUSE_MS - now);
+}

package/dist/chat/quote.d.ts

@@ -1,2 +1,6 @@
 export declare function quoteOf(selected: string): string | null;
 export declare function withQuote(quote: string, message: string): string;
+export declare function splitQuote(text: string): {
+    quote: string;
+    rest: string;
+} | null;

package/dist/chat/quote.js

@@ -23,3 +23,22 @@ export function withQuote(quote, message) {
         .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) {
+    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/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.d.ts

@@ -12,13 +12,19 @@ export interface StashedPrompt {
     mentions: string[];
     skills: string[];
     attachments: StashedAttachment[];
+    quote?: StashedQuote;
     createdAt: number;
 }
+export interface StashedQuote {
+    text: string;
+    chatId: string;
+    itemId: string;
+}
 export declare function parseStash(raw: string | null): StashedPrompt[];
 export declare function withStashed(prompts: StashedPrompt[], entry: StashedPrompt): StashedPrompt[];
-export declare function stashedFrom(draft: ChatDraft, id: string, now: number): StashedPrompt | null;
+export declare function stashedFrom(draft: ChatDraft, id: string, now: number, chatId: string): StashedPrompt | null;
 export declare const useStash: import("zustand").UseBoundStore<import("zustand").StoreApi<{
     prompts: StashedPrompt[];
 }>>;
-export declare function stashDraft(draft: ChatDraft): boolean;
+export declare function stashDraft(draft: ChatDraft, chatId: string): boolean;
 export declare function forgetStashed(id: string): void;