@adecore/agents-react 0.0.1 → 0.17.0-beta.2

package/dist/chat/logic/tools.js

@@ -0,0 +1,82 @@
+import { isRecord } from './json.js';
+import { toolEntry } from './tool-catalog.js';
+function str(value) {
+    return typeof value === 'string' ? value : null;
+}
+/* The one line that says what a tool call is about: the command, the file, the pattern. */
+export function toolSummary(name, input) {
+    if (!isRecord(input)) {
+        return '';
+    }
+    const known = toolEntry(name);
+    if (known === undefined) {
+        // A tool nobody wrote down, an MCP one above all, gets its best guess from the first string it was given.
+        const first = Object.values(input).find((value) => typeof value === 'string');
+        return typeof first === 'string' ? first : '';
+    }
+    for (const key of known.summary) {
+        const value = str(input[key]);
+        if (value !== null) {
+            return value;
+        }
+    }
+    return '';
+}
+// What `GET /fs/file` will serve; a path with another suffix is not worth asking the host about.
+const IMAGE_SUFFIXES = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.svg'];
+/* The image file a tool call looked at, so the row can draw it; null for every other call. */
+export function readImagePath(name, input) {
+    if (toolEntry(name)?.readsImage !== true) {
+        return null;
+    }
+    const path = isRecord(input) ? str(input.file_path) : null;
+    if (path === null) {
+        return null;
+    }
+    const lowered = path.toLowerCase();
+    return IMAGE_SUFFIXES.some((suffix) => lowered.endsWith(suffix)) ? path : null;
+}
+/* The before and after text of a file-changing tool call, so the thread can show it as a diff. */
+export function fileChanges(name, input) {
+    if (!isRecord(input)) {
+        return [];
+    }
+    const path = str(input.file_path) ?? '';
+    if (name === 'Edit') {
+        return [{ path, before: str(input.old_string) ?? '', after: str(input.new_string) ?? '' }];
+    }
+    if (name === 'Write') {
+        return [{ path, before: '', after: str(input.content) ?? '' }];
+    }
+    if (name === 'MultiEdit' && Array.isArray(input.edits)) {
+        return input.edits.filter(isRecord).map((edit) => ({ path, before: str(edit.old_string) ?? '', after: str(edit.new_string) ?? '' }));
+    }
+    return [];
+}
+export function isFileChange(name) {
+    return toolEntry(name)?.changesFiles === true;
+}
+/* The unified diffs a provider put next to a tool call; empty for one that reports before and after. */
+export function unifiedChanges(tool) {
+    return (tool.changes ?? []).filter((change) => change.diff !== '');
+}
+/* The same, for the copy an approval carries so the person can read what they are approving. */
+export function approvalChanges(input) {
+    const changes = isRecord(input) ? input.changes : null;
+    if (!Array.isArray(changes)) {
+        return [];
+    }
+    return changes.filter((change) => isRecord(change) && typeof change.path === 'string' && typeof change.diff === 'string' && change.diff !== '');
+}
+/* Whether a settled call is worth a row in the turn's changed files card. */
+export function hasFileChanges(tool) {
+    return unifiedChanges(tool).length > 0 || fileChanges(tool.name, tool.input).length > 0;
+}
+/* When a running call started: what the CLI reported, or the moment the call appeared. */
+export function toolStartedAt(tool) {
+    return tool.progress?.startedAt ?? tool.createdAt;
+}
+// Keep the full buffer so the renderer can carry ANSI state into the visible tail.
+export function liveOutput(tool) {
+    return tool.progress?.output || null;
+}

package/dist/chat/logic/welcome.d.ts

@@ -0,0 +1,2 @@
+export type DayPart = 'morning' | 'afternoon' | 'evening' | 'night';
+export declare function dayPartOf(now: Date): DayPart;

package/dist/chat/logic/welcome.js

@@ -0,0 +1,10 @@
+export function dayPartOf(now) {
+    const hour = now.getHours();
+    if (hour < 5) {
+        return 'night';
+    }
+    if (hour < 12) {
+        return 'morning';
+    }
+    return hour < 18 ? 'afternoon' : 'evening';
+}

package/dist/chat/logic/workflow.d.ts

@@ -0,0 +1,14 @@
+import type { ChatSubagentStatus, ChatWorkflow, ChatWorkflowAgent } from '@adecore/agent-contracts';
+export type WorkflowAgentState = ChatSubagentStatus | 'waiting' | 'stopped';
+export interface WorkflowAgentView {
+    agent: ChatWorkflowAgent;
+    state: WorkflowAgentState;
+}
+export interface WorkflowPhaseView {
+    key: string;
+    title: string | null;
+    agents: WorkflowAgentView[];
+}
+export declare function workflowAgentState(agent: ChatWorkflowAgent, workflowRunning: boolean): WorkflowAgentState;
+export declare function workflowPhases(workflow: ChatWorkflow, workflowRunning: boolean): WorkflowPhaseView[];
+export declare function workflowAgentTime(view: WorkflowAgentView): string | null;

package/dist/chat/logic/workflow.js

@@ -0,0 +1,47 @@
+import i18next from 'i18next';
+import { formatElapsedShort } from '@adecore/ui/format';
+export function workflowAgentState(agent, workflowRunning) {
+    if (agent.status !== 'running') {
+        return agent.status;
+    }
+    if (!workflowRunning) {
+        return 'stopped';
+    }
+    return agent.startedAt === null ? 'waiting' : 'running';
+}
+/*
+ * The phases in the order the script announced them, each with the agents it started in it. A phase
+ * announced ahead of its agents is there without any, and agents of no known phase come first, untitled.
+ */
+export function workflowPhases(workflow, workflowRunning) {
+    const known = new Map(workflow.phases.map((phase) => [phase.index, phase]));
+    const loose = [];
+    const byPhase = new Map();
+    for (const agent of workflow.agents) {
+        const view = { agent, state: workflowAgentState(agent, workflowRunning) };
+        if (agent.phaseIndex === null || !known.has(agent.phaseIndex)) {
+            loose.push(view);
+            continue;
+        }
+        byPhase.set(agent.phaseIndex, [...(byPhase.get(agent.phaseIndex) ?? []), view]);
+    }
+    const phases = workflow.phases.map((phase) => ({ key: `phase-${phase.index}`, title: phase.title, agents: byPhase.get(phase.index) ?? [] }));
+    return loose.length > 0 ? [{ key: 'loose', title: null, agents: loose }, ...phases] : phases;
+}
+/* What the line of an agent that is not at work says about its time; one at work counts on by itself. */
+export function workflowAgentTime(view) {
+    const duration = view.agent.durationMs === null ? null : formatElapsedShort(view.agent.durationMs);
+    switch (view.state) {
+        case 'running':
+            return null;
+        case 'waiting':
+            return i18next.t('agent-chat:rows.workflow.waiting');
+        case 'stopped':
+            return i18next.t('agent-chat:rows.workflow.stopped');
+        case 'done':
+        case 'failed':
+            return duration === null
+                ? i18next.t(`agent-chat:common.status.${view.state}`)
+                : i18next.t(`agent-chat:rows.subagent.${view.state}In`, { duration });
+    }
+}

package/dist/chat/mentions.d.ts

@@ -0,0 +1,65 @@
+export declare const MENTION_DRAG_TYPE = "application/x-adecore-mention";
+export declare const LEGACY_MENTION_DRAG_TYPE = "application/x-ruimte-mention";
+export declare const MENTION_DRAG_TYPES: readonly ["application/x-adecore-mention", "application/x-ruimte-mention"];
+export declare function carriesMentions(types: readonly string[]): boolean;
+export declare function droppedMentions(data: Pick<DataTransfer, 'getData'>): string[];
+export declare function writeMentionDrag(data: Pick<DataTransfer, 'setData'>, paths: readonly string[], legacy?: boolean): void;
+export interface MentionQuery {
+    start: number;
+    query: string;
+}
+export type ChipSegment = {
+    kind: 'text';
+    text: string;
+} | {
+    kind: 'mention';
+    path: string;
+} | {
+    kind: 'skill';
+    name: string;
+};
+export declare function findMentionQuery(text: string, caret: number): MentionQuery | null;
+export declare function findSkillQuery(text: string, caret: number): MentionQuery | null;
+export declare function insertToken(text: string, query: MentionQuery, sigil: string, value: string): {
+    text: string;
+    caret: number;
+};
+export declare function dropQuery(text: string, query: MentionQuery): {
+    text: string;
+    caret: number;
+};
+export declare function insertMention(text: string, query: MentionQuery, path: string): {
+    text: string;
+    caret: number;
+};
+export declare function insertSkill(text: string, query: MentionQuery, name: string): {
+    text: string;
+    caret: number;
+};
+export interface MentionSearch {
+    query: string | null;
+    files: string[];
+}
+export declare const NO_MENTION_SEARCH: MentionSearch;
+export type MentionPick<T> = {
+    kind: 'chat';
+    chat: T;
+} | {
+    kind: 'file';
+    path: string;
+};
+export declare function mentionPick<T>(index: number, chats: readonly T[], search: MentionSearch, query: string): MentionPick<T> | null;
+export declare function presentMentions(text: string, chosen: string[]): string[];
+export declare function presentSkills(text: string, chosen: string[]): string[];
+export declare function chipText(segment: ChipSegment): string;
+export declare function pastedMentions(text: string): string[];
+export interface TextRange {
+    from: number;
+    to: number;
+}
+export interface ChipRange extends TextRange {
+    kind: 'mention' | 'skill';
+    value: string;
+}
+export declare function chipRanges(text: string, mentions: string[], skills?: string[], excluded?: readonly TextRange[]): ChipRange[];
+export declare function tokenizeChips(text: string, mentions: string[], skills?: string[]): ChipSegment[];

package/dist/chat/mentions.js

@@ -0,0 +1,184 @@
+/* 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];
+export function carriesMentions(types) {
+    return MENTION_DRAG_TYPES.some((type) => types.includes(type));
+}
+export function droppedMentions(data) {
+    const text = data.getData(MENTION_DRAG_TYPE) || data.getData(LEGACY_MENTION_DRAG_TYPE);
+    return text.trim() === '' ? [] : text.trim().split(/\s+/);
+}
+export function writeMentionDrag(data, paths, legacy = true) {
+    const text = paths.join(' ');
+    data.setData(MENTION_DRAG_TYPE, text);
+    if (legacy) {
+        data.setData(LEGACY_MENTION_DRAG_TYPE, text);
+    }
+}
+function isBoundary(char) {
+    return char === undefined || /\s/.test(char);
+}
+// A path at the end of a sentence still counts, so "open @a.ts." is a mention of a.ts.
+function isTokenEnd(char) {
+    return isBoundary(char) || /[.,;:!?)]/.test(char);
+}
+/*
+ * The `<sigil>word` the caret sits in, if any. The sigil has to open a word (start of text or after
+ * whitespace) so an email address never opens the picker, and the word may not have been
+ * closed with whitespace yet.
+ */
+function findQuery(text, caret, sigil) {
+    const before = text.slice(0, caret);
+    const at = before.lastIndexOf(sigil);
+    if (at < 0 || !isBoundary(before[at - 1])) {
+        return null;
+    }
+    const query = before.slice(at + 1);
+    if (/\s/.test(query) || !isBoundary(text[caret])) {
+        return null;
+    }
+    return { start: at, query };
+}
+export function findMentionQuery(text, caret) {
+    return findQuery(text, caret, '@');
+}
+/* The `$word` the caret sits in. The name has to start with a letter, so `$20` and `$1e6` stay text. */
+export function findSkillQuery(text, caret) {
+    const found = findQuery(text, caret, '$');
+    return found === null || (found.query !== '' && !/^[A-Za-z]/.test(found.query)) ? null : found;
+}
+/* Replaces the `<sigil>query` under the caret with the chosen token and a space, and says where the caret goes. */
+export function insertToken(text, query, sigil, value) {
+    const end = query.start + 1 + query.query.length;
+    const token = `${sigil}${value} `;
+    return { text: `${text.slice(0, query.start)}${token}${text.slice(end)}`, caret: query.start + token.length };
+}
+/* Takes the `<sigil>query` under the caret out, for a pick that lands beside the text instead of in it. */
+export function dropQuery(text, query) {
+    return {
+        text: `${text.slice(0, query.start)}${text.slice(query.start + 1 + query.query.length)}`,
+        caret: query.start
+    };
+}
+export function insertMention(text, query, path) {
+    return insertToken(text, query, '@', path);
+}
+export function insertSkill(text, query, name) {
+    return insertToken(text, query, '$', name);
+}
+export const NO_MENTION_SEARCH = { query: null, files: [] };
+/* What Enter or Tab takes from the `@` list at `index`. Files still on screen from an older query are never taken. */
+export function mentionPick(index, chats, search, query) {
+    const chat = chats[index];
+    if (chat !== undefined) {
+        return { kind: 'chat', chat };
+    }
+    if (search.query !== query) {
+        return null;
+    }
+    const path = search.files[index - chats.length] ?? search.files[0];
+    return path === undefined ? null : { kind: 'file', path };
+}
+function findToken(text, sigil, value, from) {
+    const token = `${sigil}${value}`;
+    let index = text.indexOf(token, from);
+    while (index >= 0) {
+        if (isBoundary(text[index - 1]) && isTokenEnd(text[index + token.length])) {
+            return index;
+        }
+        index = text.indexOf(token, index + 1);
+    }
+    return -1;
+}
+function present(text, sigil, chosen) {
+    const found = [];
+    for (const value of new Set(chosen)) {
+        const index = findToken(text, sigil, value, 0);
+        if (index >= 0) {
+            found.push({ index, value });
+        }
+    }
+    return found.sort((a, b) => a.index - b.index).map((entry) => entry.value);
+}
+/* The chosen mentions that still sit in the text as a whole `@path` token, in text order and without doubles. */
+export function presentMentions(text, chosen) {
+    return present(text, '@', chosen);
+}
+/* The chosen skills that still sit in the text as a whole `$name` token, in text order and without doubles. */
+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.
+ */
+export function chipText(segment) {
+    if (segment.kind === 'mention') {
+        return `@${segment.path}`;
+    }
+    if (segment.kind === 'skill') {
+        return `$${segment.name}`;
+    }
+    return segment.text;
+}
+/*
+ * The paths in a pasted text that is nothing but `@path` tokens, which is what copying mentions from
+ * a list of files puts on the clipboard. Any other text, an email address included, is text.
+ */
+export function pastedMentions(text) {
+    const tokens = text.trim().split(/\s+/);
+    if (tokens.some((token) => !/^@[^\s@]+$/.test(token))) {
+        return [];
+    }
+    return [...new Set(tokens.map((token) => token.slice(1)))];
+}
+/*
+ * Where the chosen mentions and skills sit in the text, in text order; longer values win when one
+ * prefixes another. A token that overlaps an excluded range (a code span, say) is text.
+ */
+export function chipRanges(text, mentions, skills = [], excluded = []) {
+    const tokens = [
+        ...[...new Set(mentions)].map((value) => ({ sigil: '@', kind: 'mention', value })),
+        ...[...new Set(skills)].map((value) => ({ sigil: '$', kind: 'skill', value }))
+    ].sort((a, b) => b.value.length - a.value.length);
+    const allowed = (from, to) => !excluded.some((range) => from < range.to && to > range.from);
+    const ranges = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        let best = null;
+        for (const token of tokens) {
+            const length = token.value.length + 1;
+            let index = findToken(text, token.sigil, token.value, cursor);
+            while (index >= 0 && !allowed(index, index + length)) {
+                index = findToken(text, token.sigil, token.value, index + 1);
+            }
+            if (index >= 0 && (best === null || index < best.from)) {
+                best = { from: index, to: index + length, kind: token.kind, value: token.value };
+            }
+        }
+        if (best === null) {
+            break;
+        }
+        ranges.push(best);
+        cursor = best.to;
+    }
+    return ranges;
+}
+/* Splits the text so a renderer can draw the mentions and skills as chips. */
+export function tokenizeChips(text, mentions, skills = []) {
+    const segments = [];
+    let cursor = 0;
+    for (const range of chipRanges(text, mentions, skills)) {
+        if (range.from > cursor) {
+            segments.push({ kind: 'text', text: text.slice(cursor, range.from) });
+        }
+        segments.push(range.kind === 'mention' ? { kind: 'mention', path: range.value } : { kind: 'skill', name: range.value });
+        cursor = range.to;
+    }
+    if (cursor < text.length) {
+        segments.push({ kind: 'text', text: text.slice(cursor) });
+    }
+    return segments;
+}

package/dist/chat/persisted-json.d.ts

@@ -0,0 +1,5 @@
+export interface PersistedJson<T> {
+    read(): T;
+    write(value: T): boolean;
+}
+export declare function persistedJson<T>(key: string | (() => string), parse: (raw: string | null) => T, fallback: T, legacyKeys?: () => readonly string[]): PersistedJson<T>;

package/dist/chat/persisted-json.js

@@ -0,0 +1,58 @@
+import { chatStorageAdapter, hydrateChatStorage } from '../storage.js';
+export function persistedJson(key, parse, fallback, legacyKeys = () => []) {
+    let memory = fallback;
+    let unwritten = false;
+    const currentKey = () => (typeof key === 'string' ? key : key());
+    return {
+        read: () => {
+            hydrateChatStorage();
+            if (unwritten) {
+                return memory;
+            }
+            try {
+                const storage = chatStorageAdapter();
+                if (!storage) {
+                    return memory;
+                }
+                let raw = storage.getItem(currentKey());
+                if (raw === null) {
+                    for (const legacy of legacyKeys()) {
+                        raw = storage.getItem(legacy);
+                        if (raw !== null) {
+                            // Keep the old key for clients still using it, and migrate without changing the record.
+                            try {
+                                storage.setItem(currentKey(), raw);
+                            }
+                            catch {
+                                // A full storage still lets the existing record be read.
+                            }
+                            break;
+                        }
+                    }
+                }
+                memory = parse(raw);
+                return memory;
+            }
+            catch {
+                return memory;
+            }
+        },
+        write: (value) => {
+            hydrateChatStorage();
+            memory = value;
+            unwritten = true;
+            try {
+                const storage = chatStorageAdapter();
+                if (!storage) {
+                    return false;
+                }
+                storage.setItem(currentKey(), JSON.stringify(value));
+                unwritten = false;
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    };
+}

package/dist/chat/preferences.d.ts

@@ -0,0 +1,27 @@
+import type { AgentKind, ChatPreferencesPayload, ModelSelection, ProviderInfo, ProviderAccounts, RuntimeMode } from '@adecore/agent-contracts';
+export interface ChatPreferences {
+    selectionByProvider: Partial<Record<AgentKind, ModelSelection>>;
+    lastProvider: AgentKind | null;
+    runtimeMode: RuntimeMode;
+    terminalRuntimeMode: RuntimeMode;
+    accountByMachine: Record<string, Partial<Record<AgentKind, string>>>;
+    changedAt: number;
+}
+export declare const DEFAULT_CHAT_PREFERENCES: ChatPreferences;
+export declare function parseChatPreferences(raw: string | null): ChatPreferences;
+export declare function defaultProvider(preferences: ChatPreferences): AgentKind | null;
+export declare function selectionFor(preferences: ChatPreferences, provider: AgentKind | null | undefined): ModelSelection | null;
+export declare function startingSelection(preferences: ChatPreferences, provider: ProviderInfo): ModelSelection | null;
+export declare function withSelection(preferences: ChatPreferences, provider: AgentKind, selection: ModelSelection): ChatPreferences;
+export declare function accountFor(preferences: ChatPreferences, scopeId: string, provider: AgentKind, accounts?: ProviderAccounts | null): string | null;
+export declare function withAccount(preferences: ChatPreferences, scopeId: string, provider: AgentKind, account: string | null): ChatPreferences;
+export declare function chatPreferencesPayload(preferences: ChatPreferences, scopeId: string, accounts?: ProviderAccounts | null): ChatPreferencesPayload;
+export declare const useChatPreferences: import("zustand").UseBoundStore<import("zustand").StoreApi<ChatPreferences>>;
+export declare function readChatPreferences(): ChatPreferences;
+export declare let CHAT_PREFERENCES_KEY: string;
+export declare function chatPreferencesKey(): string;
+export declare function reloadChatPreferences(): void;
+export declare function rememberChatPreferences(patch: Partial<ChatPreferences>): void;
+export declare function rememberChatSelection(provider: AgentKind, selection: ModelSelection): void;
+export declare function rememberChatAccount(scopeId: string, provider: AgentKind, account: string | null): void;
+export declare function forgetChatSelection(provider: AgentKind): void;

package/dist/chat/preferences.js

@@ -0,0 +1,139 @@
+import { chatStorageKey, chatStorageLegacyKeys, createChatStore, onChatStorageConfiguration } from '../storage.js';
+import { persistedJson } from './persisted-json.js';
+const storageKey = () => chatStorageKey('preferences');
+export const DEFAULT_CHAT_PREFERENCES = {
+    selectionByProvider: {},
+    lastProvider: null,
+    runtimeMode: 'full-access',
+    terminalRuntimeMode: 'full-access',
+    accountByMachine: {},
+    changedAt: 0
+};
+/*
+ * Only the fields we know today, so what an older build wrote (one global `selection`, the plan
+ * toggle's `interactionMode`) falls away here instead of riding along in every later write. A
+ * global selection cannot be mapped back onto a provider, so it is dropped: one lost pick.
+ */
+export function parseChatPreferences(raw) {
+    if (raw === null) {
+        return DEFAULT_CHAT_PREFERENCES;
+    }
+    try {
+        const stored = JSON.parse(raw);
+        return {
+            selectionByProvider: { ...stored.selectionByProvider },
+            lastProvider: stored.lastProvider ?? null,
+            runtimeMode: stored.runtimeMode ?? DEFAULT_CHAT_PREFERENCES.runtimeMode,
+            terminalRuntimeMode: stored.terminalRuntimeMode ?? DEFAULT_CHAT_PREFERENCES.terminalRuntimeMode,
+            accountByMachine: { ...stored.accountByMachine },
+            changedAt: typeof stored.changedAt === 'number' ? stored.changedAt : 0
+        };
+    }
+    catch {
+        return DEFAULT_CHAT_PREFERENCES;
+    }
+}
+/* Which CLI a chat opens on when its node names none: the last one a model was picked for. */
+export function defaultProvider(preferences) {
+    return preferences.lastProvider;
+}
+/* The model a chat of this provider starts with; null lets the host fall back to the CLI's own default. */
+export function selectionFor(preferences, provider) {
+    const owner = provider ?? preferences.lastProvider;
+    if (owner === null) {
+        return null;
+    }
+    return preferences.selectionByProvider[owner] ?? null;
+}
+export function startingSelection(preferences, provider) {
+    return selectionFor(preferences, provider.kind) ?? (provider.defaultModel === null ? null : { model: provider.defaultModel, options: {} });
+}
+/* The pick lands in its provider's slot and makes that provider the global default. */
+export function withSelection(preferences, provider, selection) {
+    return {
+        ...preferences,
+        selectionByProvider: { ...preferences.selectionByProvider, [provider]: selection },
+        lastProvider: provider
+    };
+}
+/*
+ * The account a new agent of this CLI starts under on this machine; null is the CLI's default account.
+ * Given the machine's accounts, a pick it turned off or removed is the default account again, so a new
+ * chat is never refused over it; `undefined` is a machine that did not say yet, where the pick stands.
+ */
+export function accountFor(preferences, scopeId, provider, accounts) {
+    const picked = preferences.accountByMachine[scopeId]?.[provider] ?? null;
+    if (picked === null || accounts === undefined) {
+        return picked;
+    }
+    const account = accounts?.accounts[picked];
+    return account?.kind === provider && account.enabled !== false ? picked : null;
+}
+/* The default account is what an absent pick means, so picking it takes the pick away. */
+export function withAccount(preferences, scopeId, provider, account) {
+    const { [provider]: _previous, ...others } = preferences.accountByMachine[scopeId] ?? {};
+    const picks = account === null || account === provider ? others : { ...others, [provider]: account };
+    const { [scopeId]: _machine, ...machines } = preferences.accountByMachine;
+    return { ...preferences, accountByMachine: Object.keys(picks).length === 0 ? machines : { ...machines, [scopeId]: picks } };
+}
+/* What a machine starts a chat with when it starts one with no client mounting it; `accounts` as `accountFor` takes them. */
+export function chatPreferencesPayload(preferences, scopeId, accounts) {
+    const picks = Object.keys(preferences.accountByMachine[scopeId] ?? {}).flatMap((provider) => {
+        const account = accountFor(preferences, scopeId, provider, accounts);
+        return account === null ? [] : [[provider, account]];
+    });
+    return {
+        runtimeMode: preferences.runtimeMode,
+        terminalRuntimeMode: preferences.terminalRuntimeMode,
+        selections: preferences.selectionByProvider,
+        ...(picks.length === 0 ? {} : { accounts: Object.fromEntries(picks) }),
+        changedAt: preferences.changedAt
+    };
+}
+const storage = persistedJson(storageKey, parseChatPreferences, DEFAULT_CHAT_PREFERENCES, () => chatStorageLegacyKeys('preferences'));
+/* What a new agent starts with: the last model and modes the person picked, like a remembered default. */
+export const useChatPreferences = createChatStore(() => DEFAULT_CHAT_PREFERENCES, (store) => store.setState(storage.read(), true));
+export function readChatPreferences() {
+    return useChatPreferences.getState();
+}
+/* Where the remembered default is kept, which an app with more than one window of the same origin listens for. */
+export let CHAT_PREFERENCES_KEY = storageKey();
+onChatStorageConfiguration(() => {
+    CHAT_PREFERENCES_KEY = storageKey();
+});
+export function chatPreferencesKey() {
+    return storageKey();
+}
+/* Reads the remembered default again, once another window of the same origin wrote it. */
+export function reloadChatPreferences() {
+    useChatPreferences.setState(storage.read(), true);
+}
+function write(preferences) {
+    const next = { ...preferences, changedAt: Date.now() };
+    useChatPreferences.setState(next);
+    storage.write(next);
+}
+/* The composer writes here on every change and the settings dialog too; both edit the same remembered default. */
+export function rememberChatPreferences(patch) {
+    write({ ...useChatPreferences.getState(), ...patch });
+}
+export function rememberChatSelection(provider, selection) {
+    const current = useChatPreferences.getState();
+    const previous = current.selectionByProvider[provider];
+    if (current.lastProvider === provider &&
+        previous?.model === selection.model &&
+        Object.keys(previous.options).length === Object.keys(selection.options).length &&
+        Object.entries(selection.options).every(([key, value]) => previous.options[key] === value)) {
+        return;
+    }
+    write(withSelection(current, provider, selection));
+}
+export function rememberChatAccount(scopeId, provider, account) {
+    write(withAccount(useChatPreferences.getState(), scopeId, provider, account));
+}
+/* Back to the CLI's own default for this provider; the other providers keep what they had. */
+export function forgetChatSelection(provider) {
+    const current = useChatPreferences.getState();
+    const { [provider]: _dropped, ...rest } = current.selectionByProvider;
+    write({ ...current, selectionByProvider: rest, lastProvider: current.lastProvider === provider ? null : current.lastProvider });
+}

package/dist/chat/quote.d.ts

@@ -0,0 +1,2 @@
+export declare function quoteOf(selected: string): string | null;
+export declare function withQuote(quote: string, message: string): string;

package/dist/chat/quote.js

@@ -0,0 +1,25 @@
+/*
+ * The text a selection in an answer quotes: its lines without trailing spaces or the blank lines
+ * around them, and at most one blank line in a row. A selection of only whitespace quotes nothing.
+ */
+export function quoteOf(selected) {
+    const text = selected
+        .replace(/\r\n?/g, '\n')
+        .split('\n')
+        .map((line) => line.replace(/\s+$/, ''))
+        .join('\n')
+        .replace(/^\n+|\n+$/g, '')
+        .replace(/\n{3,}/g, '\n\n');
+    return text.trim() === '' ? null : text;
+}
+/* The message as it goes out: the quote as a markdown blockquote, a blank line, then what was typed. */
+export function withQuote(quote, message) {
+    if (quote === '') {
+        return message;
+    }
+    const block = quote
+        .split('\n')
+        .map((line) => (line === '' ? '>' : `> ${line}`))
+        .join('\n');
+    return message === '' ? block : `${block}\n\n${message}`;
+}