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

package/src/chat/logic/tools.ts

@@ -0,0 +1,102 @@
+import type { ChatFileChange, ChatToolItem } from '@adecore/agent-contracts';
+import { isRecord } from './json';
+import { toolEntry } from './tool-catalog';
+
+export interface FileChange {
+    path: string;
+    before: string;
+    after: string;
+}
+
+function str(value: unknown): string | null {
+    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: string, input: unknown): string {
+    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: string, input: unknown): string | null {
+    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: string, input: unknown): FileChange[] {
+    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: string): boolean {
+    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: ChatToolItem): ChatFileChange[] {
+    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: unknown): ChatFileChange[] {
+    const changes = isRecord(input) ? input.changes : null;
+    if (!Array.isArray(changes)) {
+        return [];
+    }
+    return changes.filter(
+        (change): change is ChatFileChange => 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: ChatToolItem): boolean {
+    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: ChatToolItem): number {
+    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: ChatToolItem): string | null {
+    return tool.progress?.output || null;
+}

package/src/chat/logic/welcome.ts

@@ -0,0 +1,13 @@
+/* The part of the day a greeting names, on the local clock; the night runs until five. */
+export type DayPart = 'morning' | 'afternoon' | 'evening' | 'night';
+
+export function dayPartOf(now: Date): DayPart {
+    const hour = now.getHours();
+    if (hour < 5) {
+        return 'night';
+    }
+    if (hour < 12) {
+        return 'morning';
+    }
+    return hour < 18 ? 'afternoon' : 'evening';
+}

package/src/chat/logic/workflow.ts

@@ -0,0 +1,66 @@
+import i18next from 'i18next';
+import type { ChatSubagentStatus, ChatWorkflow, ChatWorkflowAgent } from '@adecore/agent-contracts';
+import { formatElapsedShort } from '@adecore/ui/format';
+
+/* `waiting` has not started yet; `stopped` was still at work by the last report when the workflow ended. */
+export type WorkflowAgentState = ChatSubagentStatus | 'waiting' | 'stopped';
+
+export interface WorkflowAgentView {
+    agent: ChatWorkflowAgent;
+    state: WorkflowAgentState;
+}
+
+export interface WorkflowPhaseView {
+    key: string;
+    /* The phase's own title; null for agents outside any phase the script announced. */
+    title: string | null;
+    agents: WorkflowAgentView[];
+}
+
+export function workflowAgentState(agent: ChatWorkflowAgent, workflowRunning: boolean): WorkflowAgentState {
+    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: ChatWorkflow, workflowRunning: boolean): WorkflowPhaseView[] {
+    const known = new Map(workflow.phases.map((phase) => [phase.index, phase]));
+    const loose: WorkflowAgentView[] = [];
+    const byPhase = new Map<number, WorkflowAgentView[]>();
+    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: WorkflowAgentView): string | null {
+    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/src/chat/mentions.ts

@@ -0,0 +1,232 @@
+/* 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;
+
+export function carriesMentions(types: readonly string[]): boolean {
+    return MENTION_DRAG_TYPES.some((type) => types.includes(type));
+}
+
+export function droppedMentions(data: Pick<DataTransfer, 'getData'>): string[] {
+    const text = data.getData(MENTION_DRAG_TYPE) || data.getData(LEGACY_MENTION_DRAG_TYPE);
+    return text.trim() === '' ? [] : text.trim().split(/\s+/);
+}
+
+export function writeMentionDrag(data: Pick<DataTransfer, 'setData'>, paths: readonly string[], legacy = true): void {
+    const text = paths.join(' ');
+    data.setData(MENTION_DRAG_TYPE, text);
+    if (legacy) {
+        data.setData(LEGACY_MENTION_DRAG_TYPE, text);
+    }
+}
+
+export interface MentionQuery {
+    // Index of the sigil in the text.
+    start: number;
+    query: string;
+}
+
+export type ChipSegment = { kind: 'text'; text: string } | { kind: 'mention'; path: string } | { kind: 'skill'; name: string };
+
+function isBoundary(char: string | undefined): boolean {
+    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: string | undefined): boolean {
+    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: string, caret: number, sigil: string): MentionQuery | null {
+    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: string, caret: number): MentionQuery | null {
+    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: string, caret: number): MentionQuery | null {
+    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: string, query: MentionQuery, sigil: string, value: string): { text: string; caret: number } {
+    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: string, query: MentionQuery): { text: string; caret: number } {
+    return {
+        text: `${text.slice(0, query.start)}${text.slice(query.start + 1 + query.query.length)}`,
+        caret: query.start
+    };
+}
+
+export function insertMention(text: string, query: MentionQuery, path: string): { text: string; caret: number } {
+    return insertToken(text, query, '@', path);
+}
+
+export function insertSkill(text: string, query: MentionQuery, name: string): { text: string; caret: number } {
+    return insertToken(text, query, '$', name);
+}
+
+/* What a file search answered, with the query it answered, since the query moves on while the answer is on its way. */
+export interface MentionSearch {
+    query: string | null;
+    files: string[];
+}
+
+export const NO_MENTION_SEARCH: MentionSearch = { query: null, files: [] };
+
+export type MentionPick<T> = { kind: 'chat'; chat: T } | { kind: 'file'; path: string };
+
+/* What Enter or Tab takes from the `@` list at `index`. Files still on screen from an older query are never taken. */
+export function mentionPick<T>(index: number, chats: readonly T[], search: MentionSearch, query: string): MentionPick<T> | null {
+    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: string, sigil: string, value: string, from: number): number {
+    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: string, sigil: string, chosen: string[]): string[] {
+    const found: Array<{ index: number; value: string }> = [];
+    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: string, chosen: string[]): string[] {
+    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: 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.
+ */
+export function chipText(segment: ChipSegment): string {
+    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: string): string[] {
+    const tokens = text.trim().split(/\s+/);
+    if (tokens.some((token) => !/^@[^\s@]+$/.test(token))) {
+        return [];
+    }
+    return [...new Set(tokens.map((token) => token.slice(1)))];
+}
+
+export interface TextRange {
+    from: number;
+    to: number;
+}
+
+export interface ChipRange extends TextRange {
+    kind: 'mention' | 'skill';
+    value: string;
+}
+
+/*
+ * 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: string, mentions: string[], skills: string[] = [], excluded: readonly TextRange[] = []): ChipRange[] {
+    const tokens = [
+        ...[...new Set(mentions)].map((value) => ({ sigil: '@', kind: 'mention' as const, value })),
+        ...[...new Set(skills)].map((value) => ({ sigil: '$', kind: 'skill' as const, value }))
+    ].sort((a, b) => b.value.length - a.value.length);
+    const allowed = (from: number, to: number): boolean => !excluded.some((range) => from < range.to && to > range.from);
+    const ranges: ChipRange[] = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        let best: ChipRange | null = 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: string, mentions: string[], skills: string[] = []): ChipSegment[] {
+    const segments: ChipSegment[] = [];
+    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/src/chat/persisted-json.ts

@@ -0,0 +1,67 @@
+import { chatStorageAdapter, hydrateChatStorage } from '../storage';
+
+export interface PersistedJson<T> {
+    read(): T;
+    /* False when storage refused; the value still survives for this session. */
+    write(value: T): boolean;
+}
+
+export function persistedJson<T>(
+    key: string | (() => string),
+    parse: (raw: string | null) => T,
+    fallback: T,
+    legacyKeys: () => readonly string[] = () => []
+): PersistedJson<T> {
+    let memory = fallback;
+    let unwritten = false;
+    const currentKey = (): string => (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/src/chat/preferences.ts

@@ -0,0 +1,179 @@
+import { chatStorageKey, chatStorageLegacyKeys, createChatStore, onChatStorageConfiguration } from '../storage';
+import type { AgentKind, ChatPreferencesPayload, ModelSelection, ProviderInfo, ProviderAccounts, RuntimeMode } from '@adecore/agent-contracts';
+import { persistedJson } from './persisted-json';
+
+const storageKey = (): string => chatStorageKey('preferences');
+
+export interface ChatPreferences {
+    /* One remembered model per CLI: a slug only means something inside its own catalog. */
+    selectionByProvider: Partial<Record<AgentKind, ModelSelection>>;
+    /* Whose model was picked last, which is what a chat without a fixed provider opens on. */
+    lastProvider: AgentKind | null;
+    runtimeMode: RuntimeMode;
+    // What an agent started as a terminal node runs in; a chat picks its own mode in the composer.
+    terminalRuntimeMode: RuntimeMode;
+    /* Per machine, the account a new agent of each CLI starts under; an account id only means something on its own machine. */
+    accountByMachine: Record<string, Partial<Record<AgentKind, string>>>;
+    /* When a person last changed any of it; what settles whose pick a machine uses when several clients told it one. */
+    changedAt: number;
+}
+
+export const DEFAULT_CHAT_PREFERENCES: ChatPreferences = {
+    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: string | null): ChatPreferences {
+    if (raw === null) {
+        return DEFAULT_CHAT_PREFERENCES;
+    }
+    try {
+        const stored = JSON.parse(raw) as Partial<ChatPreferences>;
+        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: ChatPreferences): AgentKind | null {
+    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: ChatPreferences, provider: AgentKind | null | undefined): ModelSelection | null {
+    const owner = provider ?? preferences.lastProvider;
+    if (owner === null) {
+        return null;
+    }
+    return preferences.selectionByProvider[owner] ?? null;
+}
+
+export function startingSelection(preferences: ChatPreferences, provider: ProviderInfo): ModelSelection | null {
+    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: ChatPreferences, provider: AgentKind, selection: ModelSelection): ChatPreferences {
+    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: ChatPreferences, scopeId: string, provider: AgentKind, accounts?: ProviderAccounts | null): string | null {
+    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: ChatPreferences, scopeId: string, provider: AgentKind, account: string | null): ChatPreferences {
+    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: ChatPreferences, scopeId: string, accounts?: ProviderAccounts | null): ChatPreferencesPayload {
+    const picks = Object.keys(preferences.accountByMachine[scopeId] ?? {}).flatMap((provider) => {
+        const account = accountFor(preferences, scopeId, provider as AgentKind, accounts);
+        return account === null ? [] : [[provider, account] as const];
+    });
+    return {
+        runtimeMode: preferences.runtimeMode,
+        terminalRuntimeMode: preferences.terminalRuntimeMode,
+        selections: preferences.selectionByProvider,
+        ...(picks.length === 0 ? {} : { accounts: Object.fromEntries(picks) }),
+        changedAt: preferences.changedAt
+    };
+}
+
+const storage = persistedJson<ChatPreferences>(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<ChatPreferences>(
+    () => DEFAULT_CHAT_PREFERENCES,
+    (store) => store.setState(storage.read(), true)
+);
+
+export function readChatPreferences(): ChatPreferences {
+    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(): string {
+    return storageKey();
+}
+
+/* Reads the remembered default again, once another window of the same origin wrote it. */
+export function reloadChatPreferences(): void {
+    useChatPreferences.setState(storage.read(), true);
+}
+
+function write(preferences: ChatPreferences): void {
+    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: Partial<ChatPreferences>): void {
+    write({ ...useChatPreferences.getState(), ...patch });
+}
+
+export function rememberChatSelection(provider: AgentKind, selection: ModelSelection): void {
+    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: string, provider: AgentKind, account: string | null): void {
+    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: AgentKind): void {
+    const current = useChatPreferences.getState();
+    const { [provider]: _dropped, ...rest } = current.selectionByProvider;
+    write({ ...current, selectionByProvider: rest, lastProvider: current.lastProvider === provider ? null : current.lastProvider });
+}