@ruimte/agents-react 0.0.0 → 0.7.0

package/dist/chat/drafts.js

@@ -0,0 +1,104 @@
+import { create } from 'zustand';
+import { checkAttachmentLimits, uploadBytes } from './attachments';
+import { persistedJson } from './persisted-json';
+const STORAGE_KEY = 'ruimte.chat.drafts';
+export const EMPTY_DRAFT = { text: '', mentions: [], skills: [], chats: [], attachments: [], quote: '' };
+const storage = persistedJson(STORAGE_KEY, (raw) => (raw ? JSON.parse(raw) : {}), {});
+const readAll = () => storage.read();
+const store = (drafts) => storage.write(drafts);
+export const isEmptyDraft = (draft) => draft.text.trim() === '' && draft.attachments.length === 0 && draft.quote === '';
+/*
+ * 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 = create(() => ({ ids: Object.keys(readAll()) }));
+export const useHasDraft = (chatId) => useDrafts((s) => s.ids.includes(chatId));
+const trackDraft = (chatId, held) => {
+    const { ids } = useDrafts.getState();
+    if (ids.includes(chatId) === held) {
+        return;
+    }
+    useDrafts.setState({ ids: held ? [...ids, chatId] : ids.filter((id) => id !== chatId) });
+};
+/* An unsent prompt per chat node, kept across reloads so a half-written message is never lost. */
+export const readDraft = (chatId) => {
+    const record = readAll()[chatId];
+    return record
+        ? {
+            text: record.text,
+            mentions: record.mentions ?? [],
+            skills: record.skills ?? [],
+            chats: record.chats ?? [],
+            attachments: record.attachments ?? [],
+            quote: record.quote ?? ''
+        }
+        : EMPTY_DRAFT;
+};
+export const writeDraft = (chatId, draft) => {
+    const drafts = readAll();
+    trackDraft(chatId, !isEmptyDraft(draft));
+    if (isEmptyDraft(draft)) {
+        delete drafts[chatId];
+        store(drafts);
+        return;
+    }
+    drafts[chatId] = {
+        text: draft.text,
+        mentions: draft.mentions,
+        skills: draft.skills,
+        chats: draft.chats,
+        attachments: draft.attachments,
+        quote: draft.quote
+    };
+    if (store(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);
+};
+/* Text handed to a draft from outside the composer goes under what was already typed, never over it. */
+export const joinDraftText = (current, added) => (current.trim() === '' ? added : `${current.replace(/\s+$/, '')}\n\n${added}`);
+const union = (first, second) => [...first, ...second.filter((entry) => !first.includes(entry))];
+/*
+ * A queued message taken back to edit goes above what was typed since. Its files join the draft's as
+ * far as the limits let them, and the rest come back rejected, the way a dropped file would. A quote
+ * it was sent with is part of its text; the draft keeps the one it holds.
+ */
+export const takeBackIntoDraft = (current, taken) => {
+    const checked = checkAttachmentLimits(current.attachments.length, taken.attachments.map((upload) => ({ name: upload.name, mime: upload.mime, bytes: uploadBytes(upload), upload })), current.attachments.reduce((bytes, upload) => bytes + uploadBytes(upload), 0));
+    return {
+        draft: {
+            text: current.text.trim() === '' ? taken.text : joinDraftText(taken.text, current.text),
+            mentions: union(taken.mentions, current.mentions),
+            skills: union(taken.skills, current.skills),
+            chats: union(taken.chats, current.chats),
+            attachments: [...checked.accepted.map((entry) => entry.upload), ...current.attachments],
+            quote: current.quote
+        },
+        rejected: checked.rejected
+    };
+};
+/* The composers on screen, by chat. One that is not mounted reads what was offered from storage when it is. */
+const takers = new Map();
+export const takeDraftOffers = (chatId, take) => {
+    takers.set(chatId, take);
+    return () => {
+        if (takers.get(chatId) === take) {
+            takers.delete(chatId);
+        }
+    };
+};
+/*
+ * Puts text in a chat's prompt without sending it: the person reads it and presses Enter. A mounted
+ * composer owns its draft and writes it back to storage itself, so it has to be the one to take it.
+ */
+export const offerDraft = (chatId, text) => {
+    const take = takers.get(chatId);
+    if (take) {
+        take(text);
+        return;
+    }
+    const current = readDraft(chatId);
+    writeDraft(chatId, { ...current, text: joinDraftText(current.text, text) });
+};

package/dist/chat/forks.d.ts

@@ -0,0 +1,2 @@
+export declare const useForkedTurns: (chatId: string) => ReadonlySet<string>;
+export declare const useForkIdsAfter: (chatId: string, turnId: string) => string[];

package/dist/chat/forks.js

@@ -0,0 +1,26 @@
+import { useMemo } from 'react';
+import { forkIdsAfter, forkedTurnIds } from './logic/fork';
+import { useChatScope } from '../scope';
+import { useChats } from '../state/chats';
+/* The chats this client holds of one host, which is where the forks it knows of are. */
+function* forkInfosOn(byKey, owns) {
+    for (const [key, state] of Object.entries(byKey)) {
+        if (state.info.forkOf !== undefined && owns(key)) {
+            yield state.info;
+        }
+    }
+}
+/* Selectors answer a joined string, never a new array or set, and split it again in a memo. */
+const splitIds = (joined) => (joined === '' ? [] : joined.split('\n'));
+/* The turns of this chat a fork went on after, for the thread to put a line under. */
+export const useForkedTurns = (chatId) => {
+    const { owns } = useChatScope();
+    const joined = useChats((s) => [...forkedTurnIds(forkInfosOn(s.byKey, owns), chatId)].join('\n'));
+    return useMemo(() => new Set(splitIds(joined)), [joined]);
+};
+/* The forks that went on after this turn of this chat. */
+export const useForkIdsAfter = (chatId, turnId) => {
+    const { owns } = useChatScope();
+    const joined = useChats((s) => forkIdsAfter(forkInfosOn(s.byKey, owns), chatId, turnId).join('\n'));
+    return useMemo(() => splitIds(joined), [joined]);
+};

package/dist/chat/guards.d.ts

@@ -0,0 +1,12 @@
+export declare const PROMPT_MAX_CHARS = 120000;
+export declare const PROMPT_COUNTER_FROM = 100000;
+export declare const PASTE_ATTACHMENT_FROM_BYTES: number;
+export declare const pasteBecomesAttachment: (text: string) => boolean;
+export declare const pastedTextName: (taken: string[]) => string;
+export interface PromptGuard {
+    count: number;
+    visible: boolean;
+    tooLong: boolean;
+}
+export declare const promptGuard: (text: string) => PromptGuard;
+export declare const usableSlashCommands: (names: string[]) => string[];

package/dist/chat/guards.js

@@ -0,0 +1,63 @@
+// What a CLI still accepts without the turn becoming slower than the answer is worth; a Claude user
+// frame this large is legal but sluggish.
+export const PROMPT_MAX_CHARS = 120000;
+// Below this the counter would only be noise; a prompt this long is already unusual.
+export const PROMPT_COUNTER_FROM = 100000;
+/*
+ * From this many bytes a paste of text becomes a file beside the prompt instead of text in it. A log
+ * or a file that large is something to read with a tool, not words for the model to take in on
+ * every turn, and in the textarea it buries what the person actually wants to say.
+ */
+export const PASTE_ATTACHMENT_FROM_BYTES = 32 * 1024;
+const encoder = new TextEncoder();
+/* Whether pasted text is large enough to go in as an attachment. Bytes, since that is what the file weighs. */
+export const pasteBecomesAttachment = (text) => text.length * 3 >= PASTE_ATTACHMENT_FROM_BYTES && encoder.encode(text).length >= PASTE_ATTACHMENT_FROM_BYTES;
+/* A name for pasted text that no attachment of the draft has yet: paste-1.txt, paste-2.txt, ... */
+export const pastedTextName = (taken) => {
+    const names = new Set(taken);
+    let index = 1;
+    while (names.has(`paste-${index}.txt`)) {
+        index += 1;
+    }
+    return `paste-${index}.txt`;
+};
+export const promptGuard = (text) => ({
+    count: text.length,
+    visible: text.length >= PROMPT_COUNTER_FROM,
+    tooLong: text.length > PROMPT_MAX_CHARS
+});
+/*
+ * Commands the CLI lists because its own terminal has them: they change the terminal, the login or
+ * the config, or they end a session the chat node does not own.
+ */
+const TUI_ONLY = new Set([
+    'bug',
+    'color',
+    'config',
+    'doctor',
+    'exit',
+    'heapdump',
+    'help',
+    'hooks',
+    'ide',
+    'install-github-app',
+    'keybindings',
+    'login',
+    'logout',
+    'migrate-installer',
+    'privacy-settings',
+    'quit',
+    'release-notes',
+    'reload-plugins',
+    'reload-skills',
+    'rename',
+    'resume',
+    'status',
+    'statusline',
+    'terminal-setup',
+    'theme',
+    'upgrade',
+    'vim'
+]);
+/* The commands of the CLI's list that mean something in a chat node. */
+export const usableSlashCommands = (names) => names.filter((name) => !TUI_ONLY.has(name));

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

@@ -0,0 +1,3 @@
+export type PickedAnswers = Record<string, string[]>;
+export declare function toggleChoice(picked: string[], label: string): string[];
+export declare function answersToWire(picked: PickedAnswers): Record<string, string>;

package/dist/chat/logic/answers.js

@@ -0,0 +1,14 @@
+/* The separator between several choices of one question, once they are one string. */
+const SEPARATOR = ', ';
+/*
+ * Add or remove one choice of a multi select question. The picks stay a list here because a label
+ * may hold the separator itself: joined too early, such a label no longer matches itself and the
+ * choice would read as unpicked on screen.
+ */
+export function toggleChoice(picked, label) {
+    return picked.includes(label) ? picked.filter((choice) => choice !== label) : [...picked, label];
+}
+/* The wire takes one string per question, so several choices travel as one line. */
+export function answersToWire(picked) {
+    return Object.fromEntries(Object.entries(picked).map(([id, labels]) => [id, labels.join(SEPARATOR)]));
+}

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

@@ -0,0 +1,5 @@
+import type { ChatBookmark, ChatItem } from '@ruimte/agent-contracts';
+import type { TimelineRow } from './timeline';
+export declare const bookmarkLabel: (bookmark: ChatBookmark) => string;
+export declare const bookmarksInThreadOrder: (bookmarks: readonly ChatBookmark[], order: readonly string[]) => ChatBookmark[];
+export declare const bookmarkRows: (rows: readonly TimelineRow[], bookmarks: readonly ChatBookmark[], items: Readonly<Record<string, ChatItem>>) => Map<string, ChatBookmark>;

package/dist/chat/logic/bookmarks.js

@@ -0,0 +1,31 @@
+/* What a list calls a bookmark: its name, else the start of the message. */
+export const bookmarkLabel = (bookmark) => bookmark.name ?? bookmark.excerpt;
+/* The bookmarks in the order of the thread; one whose message this client does not hold goes last. */
+export const bookmarksInThreadOrder = (bookmarks, order) => {
+    const places = new Map(order.map((id, index) => [id, index]));
+    const place = (bookmark) => places.get(bookmark.itemId) ?? order.length;
+    return [...bookmarks].sort((left, right) => place(left) - place(right) || left.createdAt - right.createdAt);
+};
+/*
+ * Which row each bookmark is drawn at, by row id: the message's own row, or the fold of a settled
+ * turn that hides a reply before its last one. A bookmark on a message this client does not hold
+ * has no row.
+ */
+export const bookmarkRows = (rows, bookmarks, items) => {
+    const rowIds = new Set(rows.map((row) => row.id));
+    const folds = new Map();
+    for (const row of rows) {
+        if (row.kind === 'turn-fold') {
+            folds.set(row.turn.id, row.id);
+        }
+    }
+    const marked = new Map();
+    for (const bookmark of bookmarks) {
+        const turnId = items[bookmark.itemId]?.turnId ?? null;
+        const rowId = rowIds.has(bookmark.itemId) ? bookmark.itemId : turnId === null ? undefined : folds.get(turnId);
+        if (rowId !== undefined && !marked.has(rowId)) {
+            marked.set(rowId, bookmark);
+        }
+    }
+    return marked;
+};

package/dist/chat/logic/context-usage.d.ts

@@ -0,0 +1,12 @@
+import type { ChatContextBreakdown, ChatUsage, ModelOptionDescriptor } from '@ruimte/agent-contracts';
+export declare const CONTEXT_OPTION = "contextWindow";
+export type ContextPart = keyof ChatContextBreakdown;
+export declare const CONTEXT_PARTS: readonly ContextPart[];
+export interface ContextSegment {
+    part: ContextPart;
+    tokens: number;
+    fraction: number;
+}
+export declare const contextFraction: (usage: ChatUsage) => number;
+export declare const contextSegments: (usage: ChatUsage) => ContextSegment[] | null;
+export declare const orderOptions: (options: readonly ModelOptionDescriptor[]) => ModelOptionDescriptor[];

package/dist/chat/logic/context-usage.js

@@ -0,0 +1,20 @@
+export const CONTEXT_OPTION = 'contextWindow';
+export const CONTEXT_PARTS = ['toolOutput', 'filesRead', 'conversation', 'system'];
+export const contextFraction = (usage) => (usage.contextWindow ? Math.min(1, usage.contextTokens / usage.contextWindow) : 0);
+/* The stretches of the bar, in the legend's order; null from a host that does not estimate, which draws the plain bar. */
+export const contextSegments = (usage) => {
+    const breakdown = usage.breakdown;
+    if (!breakdown || usage.contextTokens === 0) {
+        return null;
+    }
+    const whole = Math.max(usage.contextWindow ?? 0, usage.contextTokens);
+    return CONTEXT_PARTS.map((part) => ({ part, tokens: breakdown[part], fraction: breakdown[part] / whole }));
+};
+/*
+ * The model's own knobs with the context window last: its details sit in the group right under it,
+ * and a switch like Fast mode belongs with the reasoning choice above rather than below the size.
+ */
+export const orderOptions = (options) => [
+    ...options.filter((option) => option.id !== CONTEXT_OPTION),
+    ...options.filter((option) => option.id === CONTEXT_OPTION)
+];

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

@@ -0,0 +1,44 @@
+import type { AgentKind, ChatForkPayload, ChatInfo, ChatItem, ModelSelection } from '@ruimte/agent-contracts';
+import type { TimelineRow } from './timeline';
+export declare const FORKABLE_PROVIDERS: ReadonlySet<string>;
+export interface ForkPoint {
+    turnId: string;
+    number: number;
+    total: number;
+    last: boolean;
+    prompt: string | null;
+}
+export declare const forkRefusal: (info: ChatInfo | null, turn: ChatItem | undefined) => string | null;
+export declare const summaryRefusal: (state: {
+    busy: boolean;
+    originalPresent: boolean;
+}) => string | null;
+export declare const forkIdsAfter: (infos: Iterable<ChatInfo>, chatId: string, turnId: string) => string[];
+export declare const forkedTurnIds: (infos: Iterable<ChatInfo>, chatId: string) => Set<string>;
+export declare const lastSettledTurn: (items: Record<string, ChatItem>, order: readonly string[]) => string | null;
+export declare const forkPointOf: (items: Record<string, ChatItem>, order: readonly string[], turnId: string) => ForkPoint | null;
+export declare const forkPointLabel: (point: ForkPoint, maxPrompt?: number) => string;
+export declare const turnIdOfRow: (row: TimelineRow) => string | null;
+export type ForkShape = 'node' | 'view';
+export declare const forkShapes: (origin: ForkShape) => ForkShape[];
+export interface ForkWorktreeChoice {
+    branch: string;
+    filesAfterTurn: boolean;
+}
+export interface ForkCliChoice {
+    provider: AgentKind;
+    selection: ModelSelection;
+    account?: string;
+}
+export declare const forkPayload: (input: {
+    chatId: string;
+    turnId: string;
+    title: string;
+    shape: ForkShape;
+    worktree?: ForkWorktreeChoice | null;
+    cli?: {
+        original: ForkCliChoice;
+        chosen: ForkCliChoice;
+    };
+}) => ChatForkPayload;
+export declare const branchRefusal: (branch: string, taken: readonly string[]) => string | null;

package/dist/chat/logic/fork.js

@@ -0,0 +1,138 @@
+import i18next from 'i18next';
+/* The providers whose chat a machine can fork, and go on with in a fork, are the ones with a conversation the CLI keeps. */
+export const FORKABLE_PROVIDERS = new Set(['claude', 'codex']);
+const turnsOf = (items, order) => order.flatMap((id) => {
+    const item = items[id];
+    return item?.kind === 'turn' ? [item] : [];
+});
+/*
+ * Why a chat cannot be forked after this turn right now, or null when it can. A turn still running,
+ * or any turn in the chat, is a transcript that grows while it would be copied.
+ */
+export const forkRefusal = (info, turn) => {
+    if (info === null || turn?.kind !== 'turn') {
+        return i18next.t('agent-chat:fork.refusal.notInConversation');
+    }
+    if (!FORKABLE_PROVIDERS.has(info.provider)) {
+        return i18next.t('agent-chat:fork.refusal.cliCannotFork');
+    }
+    if (info.agentSessionId === null) {
+        return i18next.t('agent-chat:fork.refusal.noConversation');
+    }
+    if (turn.state === 'running' || info.activeTurnId !== null) {
+        return i18next.t('agent-chat:fork.refusal.turnRunning');
+    }
+    return null;
+};
+/* Why a fork cannot write a summary for its original right now, or null when it can. */
+export const summaryRefusal = (state) => {
+    if (!state.originalPresent) {
+        return i18next.t('agent-chat:fork.refusal.originalGone');
+    }
+    if (state.busy) {
+        return i18next.t('agent-chat:fork.refusal.turnRunning');
+    }
+    return null;
+};
+/* The forks this client knows of that went on after this turn of this chat, in the order it holds them. */
+export const forkIdsAfter = (infos, chatId, turnId) => {
+    const ids = [];
+    for (const info of infos) {
+        if (info.forkOf?.chatId === chatId && info.forkOf.turnId === turnId) {
+            ids.push(info.chatId);
+        }
+    }
+    return ids;
+};
+/* The turns of this chat that at least one fork this client knows of went on after. */
+export const forkedTurnIds = (infos, chatId) => {
+    const turns = new Set();
+    for (const info of infos) {
+        if (info.forkOf?.chatId === chatId) {
+            turns.add(info.forkOf.turnId);
+        }
+    }
+    return turns;
+};
+/* The last turn that ended, which is where a fork from the node's menu goes on after. */
+export const lastSettledTurn = (items, order) => turnsOf(items, order).findLast((turn) => turn.state !== 'running')?.id ?? null;
+export const forkPointOf = (items, order, turnId) => {
+    const turns = turnsOf(items, order);
+    const index = turns.findIndex((turn) => turn.id === turnId);
+    const turn = turns[index];
+    if (turn === undefined) {
+        return null;
+    }
+    const asked = order.map((id) => items[id]).find((item) => item?.kind === 'user' && item.turnId === turnId);
+    const text = asked?.kind === 'user' ? asked.text : (turn.label ?? '');
+    const prompt = text
+        .split('\n')
+        .find((line) => line.trim() !== '')
+        ?.trim() ?? null;
+    return { turnId, number: index + 1, total: turns.length, last: index === turns.length - 1, prompt };
+};
+/* The line at the top of the dialog: which turn, and what it was about. */
+export const forkPointLabel = (point, maxPrompt = 60) => {
+    const where = point.last
+        ? i18next.t('agent-chat:fork.point.afterLast')
+        : i18next.t('agent-chat:fork.point.afterTurn', { number: point.number, total: point.total });
+    if (point.prompt === null) {
+        return where;
+    }
+    const prompt = point.prompt.length > maxPrompt ? `${point.prompt.slice(0, maxPrompt - 1)}…` : point.prompt;
+    return i18next.t('agent-chat:fork.point.about', { where, prompt });
+};
+/* The turn a row of the thread belongs to, which is the turn "Fork from here" on that row goes on after. */
+export const turnIdOfRow = (row) => {
+    switch (row.kind) {
+        case 'turn-start':
+        case 'turn-fold':
+            return row.turn.id;
+        case 'changed-files':
+        case 'forks':
+            return row.turnId;
+        case 'work':
+        case 'work-live':
+        case 'workflow':
+            return row.tool.turnId;
+        case 'work-group':
+            return row.tools[0]?.turnId ?? null;
+        case 'user':
+        case 'assistant':
+        case 'thinking':
+        case 'subagent':
+        case 'approval':
+        case 'question':
+            return row.item.turnId;
+        default:
+            return null;
+    }
+};
+/* What the dialog offers, first the default: a view forks into a view, and a node into a node or, when asked, a view. */
+export const forkShapes = (origin) => (origin === 'view' ? ['view'] : ['node', 'view']);
+export const forkPayload = (input) => ({
+    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 } : {}) } : {})
+});
+/* Why a branch cannot be the fork's, or null when it can. */
+export const branchRefusal = (branch, taken) => {
+    const name = branch.trim();
+    if (name === '') {
+        return i18next.t('agent-chat:fork.branch.unnamed');
+    }
+    if (taken.includes(name)) {
+        return i18next.t('agent-chat:fork.branch.taken');
+    }
+    return null;
+};

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

@@ -0,0 +1,2 @@
+import type { ChatItem } from '@ruimte/agent-contracts';
+export declare const handbackReportOf: (item: ChatItem) => string | null;

package/dist/chat/logic/handback.js

@@ -0,0 +1,8 @@
+/* The report a `SubagentHandback` call carries in `input.message` (Claude Code 2.1.273), or null for any other item. */
+export const handbackReportOf = (item) => {
+    if (item.kind !== 'tool' || item.name !== 'SubagentHandback' || typeof item.input !== 'object' || item.input === null) {
+        return null;
+    }
+    const message = item.input.message;
+    return typeof message === 'string' && message.trim() !== '' ? message : null;
+};

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

@@ -0,0 +1 @@
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;

package/dist/chat/logic/json.js

@@ -0,0 +1,2 @@
+/* A plain object, which is what a tool's input and a stored record are and an array is not. */
+export const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);

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

@@ -0,0 +1,7 @@
+import type { ChatInfo } from '@ruimte/agent-contracts';
+export interface LimitView {
+    pill: string;
+    title: string;
+    detail: string | null;
+}
+export declare const limitView: (info: Pick<ChatInfo, 'limit' | 'resumeAt' | 'activeTurnId'>, now: number) => LimitView | null;

package/dist/chat/logic/limit.js

@@ -0,0 +1,34 @@
+import i18next from 'i18next';
+import { formatMoment } from '@ruimte/ui/format/datetime';
+/*
+ * What a chat that stopped on a limit says about it, from its info alone, so a header that never holds
+ * the thread says the same as the chat. Null while the last turn stopped on nothing, or a turn runs.
+ */
+export const limitView = (info, now) => {
+    const limit = info.limit;
+    if (limit === undefined || info.activeTurnId !== null) {
+        return null;
+    }
+    const resumes = info.resumeAt === undefined ? null : formatMoment(info.resumeAt, now);
+    if (limit.kind === 'overload') {
+        return {
+            pill: resumes === null ? i18next.t('agent-chat:limit.overload.pill') : i18next.t('agent-chat:limit.overload.pillRetry', { time: resumes }),
+            title: i18next.t('agent-chat:limit.overload.title'),
+            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
+    };
+};

package/dist/chat/logic/resume-compaction.d.ts

@@ -0,0 +1,14 @@
+import type { ChatInfo, ChatItem, ProviderCapabilities } from '@ruimte/agent-contracts';
+export declare const RESUME_COMPACTION_TOKENS = 100000;
+export declare const RESUME_COMPACTION_IDLE_MS: number;
+export interface ResumeCompactionOffer {
+    turnId: string;
+    tokens: number;
+}
+export declare const resumeCompactionOffer: ({ info, compaction, items, dismissedTurnId, now }: {
+    info: ChatInfo;
+    compaction: ProviderCapabilities['compaction'] | undefined;
+    items: readonly ChatItem[];
+    dismissedTurnId: string | null;
+    now: number;
+}) => ResumeCompactionOffer | null;

package/dist/chat/logic/resume-compaction.js

@@ -0,0 +1,47 @@
+/*
+ * An absolute count, not a share of the window: reading a thread again costs per token, so 100k in a
+ * window of 1M is as expensive as 100k in a window of 200k.
+ */
+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;
+const lastTurn = (items) => {
+    for (let i = items.length - 1; i >= 0; i--) {
+        const item = items[i];
+        if (item.kind === 'turn') {
+            return item;
+        }
+    }
+    return null;
+};
+/*
+ * Whether to offer compacting before the next message. The caller passes `now`, so this stays pure
+ * and the test needs no clock.
+ */
+export const resumeCompactionOffer = ({ info, compaction, items, dismissedTurnId, now }) => {
+    if (compaction === undefined || compaction === 'none') {
+        return null;
+    }
+    if (info.activeTurnId !== null || (info.queue ?? []).length > 0) {
+        return null;
+    }
+    if (info.usage.contextTokens < RESUME_COMPACTION_TOKENS) {
+        return null;
+    }
+    const turn = lastTurn(items);
+    if (turn === null || turn.endedAt === null || turn.id === dismissedTurnId) {
+        return null;
+    }
+    if (now - turn.endedAt < RESUME_COMPACTION_IDLE_MS) {
+        return null;
+    }
+    /*
+     * `contextTokens` keeps the old number until the next request, so without this the offer would
+     * come straight back after a compaction. A native compaction is a turn without a message of the
+     * person, which is why this looks at the turn and not at the last thing that was said.
+     */
+    if (items.some((item) => item.kind === 'compaction' && item.turnId === turn.id)) {
+        return null;
+    }
+    return { turnId: turn.id, tokens: info.usage.contextTokens };
+};