@ruimte/agents-react 0.0.0 → 0.7.0

package/dist/chat/mentions.js

@@ -0,0 +1,128 @@
+/* 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-ruimte-mention';
+const isBoundary = (char) => 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.
+const isTokenEnd = (char) => 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.
+ */
+const 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 const findMentionQuery = (text, caret) => findQuery(text, caret, '@');
+/* The `$word` the caret sits in. The name has to start with a letter, so `$20` and `$1e6` stay text. */
+export const 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 const 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 const dropQuery = (text, query) => ({
+    text: `${text.slice(0, query.start)}${text.slice(query.start + 1 + query.query.length)}`,
+    caret: query.start
+});
+export const insertMention = (text, query, path) => insertToken(text, query, '@', path);
+export const insertSkill = (text, query, name) => insertToken(text, query, '$', name);
+const 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;
+};
+const 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 const presentMentions = (text, chosen) => present(text, '@', chosen);
+/* The chosen skills that still sit in the text as a whole `$name` token, in text order and without doubles. */
+export const presentSkills = (text, chosen) => present(text, '$', chosen);
+/*
+ * The characters a segment stands for, sigil included. Joined, the segments spell the text they
+ * were cut from.
+ */
+export const chipText = (segment) => {
+    if (segment.kind === 'mention') {
+        return `@${segment.path}`;
+    }
+    if (segment.kind === 'skill') {
+        return `$${segment.name}`;
+    }
+    return segment.text;
+};
+/*
+ * 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 const 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 const 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 const persistedJson: <T>(key: string, parse: (raw: string | null) => T, fallback: T) => PersistedJson<T>;

package/dist/chat/persisted-json.js

@@ -0,0 +1,24 @@
+/*
+ * A value the browser keeps between sessions. Storage that refuses, and a record written by a
+ * version that shaped it differently, both come back as the fallback rather than as an error: there
+ * is nothing a person could do about either, and the composer has to open regardless.
+ */
+export const persistedJson = (key, parse, fallback) => ({
+    read: () => {
+        try {
+            return parse(localStorage.getItem(key));
+        }
+        catch {
+            return fallback;
+        }
+    },
+    write: (value) => {
+        try {
+            localStorage.setItem(key, JSON.stringify(value));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+});

package/dist/chat/preferences.d.ts

@@ -0,0 +1,23 @@
+import type { AgentKind, ChatPreferencesPayload, ModelSelection, ProviderAccounts, RuntimeMode } from '@ruimte/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 const parseChatPreferences: (raw: string | null) => ChatPreferences;
+export declare const defaultProvider: (preferences: ChatPreferences) => AgentKind | null;
+export declare const selectionFor: (preferences: ChatPreferences, provider: AgentKind | null | undefined) => ModelSelection | null;
+export declare const withSelection: (preferences: ChatPreferences, provider: AgentKind, selection: ModelSelection) => ChatPreferences;
+export declare const accountFor: (preferences: ChatPreferences, scopeId: string, provider: AgentKind, accounts?: ProviderAccounts | null) => string | null;
+export declare const withAccount: (preferences: ChatPreferences, scopeId: string, provider: AgentKind, account: string | null) => ChatPreferences;
+export declare const chatPreferencesPayload: (preferences: ChatPreferences, scopeId: string, accounts?: ProviderAccounts | null) => ChatPreferencesPayload;
+export declare const useChatPreferences: import("zustand").UseBoundStore<import("zustand").StoreApi<ChatPreferences>>;
+export declare const readChatPreferences: () => ChatPreferences;
+export declare const rememberChatPreferences: (patch: Partial<ChatPreferences>) => void;
+export declare const rememberChatSelection: (provider: AgentKind, selection: ModelSelection) => void;
+export declare const rememberChatAccount: (scopeId: string, provider: AgentKind, account: string | null) => void;
+export declare const forgetChatSelection: (provider: AgentKind) => void;

package/dist/chat/preferences.js

@@ -0,0 +1,110 @@
+import { create } from 'zustand';
+import { persistedJson } from './persisted-json';
+const STORAGE_KEY = 'ruimte.chat.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 const 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 const defaultProvider = (preferences) => preferences.lastProvider;
+/* The model a chat of this provider starts with; null lets the host fall back to the CLI's own default. */
+export const selectionFor = (preferences, provider) => {
+    const owner = provider ?? preferences.lastProvider;
+    if (owner === null) {
+        return null;
+    }
+    return preferences.selectionByProvider[owner] ?? null;
+};
+/* The pick lands in its provider's slot and makes that provider the global default. */
+export const withSelection = (preferences, provider, selection) => ({
+    ...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 const 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 const 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 const 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(STORAGE_KEY, parseChatPreferences, DEFAULT_CHAT_PREFERENCES);
+/* What a new agent starts with: the last model and modes the person picked, like a remembered default. */
+export const useChatPreferences = create(() => storage.read());
+export const readChatPreferences = () => useChatPreferences.getState();
+const 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 const rememberChatPreferences = (patch) => {
+    write({ ...useChatPreferences.getState(), ...patch });
+};
+export const rememberChatSelection = (provider, selection) => {
+    write(withSelection(useChatPreferences.getState(), provider, selection));
+};
+export const 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 const 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 const quoteOf: (selected: string) => string | null;
+export declare const 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 const 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 const 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}`;
+};

package/dist/chat/recent-messages.d.ts

@@ -0,0 +1,17 @@
+import type { ChatItem } from '@ruimte/agent-contracts';
+export interface RecentChatMessage {
+    role: 'user' | 'assistant';
+    text: string;
+    createdAt: number;
+}
+export interface RecentChatMessages {
+    messages: RecentChatMessage[];
+    truncated: boolean;
+}
+type MessageItem = Extract<ChatItem, {
+    kind: 'user' | 'assistant';
+}>;
+export declare const recentMessages: (eligible: readonly MessageItem[], limit: number) => RecentChatMessages;
+export declare const recentChatMessages: (items: Record<string, ChatItem>, order: readonly string[], limit: number) => RecentChatMessages;
+export declare const recentSubagentMessages: (items: readonly ChatItem[], limit: number) => RecentChatMessages;
+export {};

package/dist/chat/recent-messages.js

@@ -0,0 +1,28 @@
+const MAX_TOTAL_CHARACTERS = 12_000;
+const MAX_MESSAGE_CHARACTERS = 3_000;
+const clipped = (text) => text.length <= MAX_MESSAGE_CHARACTERS ? { text, truncated: false } : { text: `${text.slice(0, MAX_MESSAGE_CHARACTERS - 1)}…`, truncated: true };
+const isMessage = (item) => item !== undefined && (item.kind === 'user' || item.kind === 'assistant') && item.text.trim() !== '';
+/* The last messages of a conversation already cut down to the ones worth reading, clipped to what a reader can take in. */
+export const recentMessages = (eligible, limit) => {
+    const candidates = eligible.slice(-limit);
+    const messages = [];
+    let characters = 0;
+    let truncated = candidates.length < eligible.length;
+    for (const item of candidates.toReversed()) {
+        const message = clipped(item.text.trim());
+        const remaining = MAX_TOTAL_CHARACTERS - characters;
+        if (remaining <= 0) {
+            truncated = true;
+            break;
+        }
+        const text = message.text.length <= remaining ? message.text : `${message.text.slice(0, Math.max(0, remaining - 1))}…`;
+        messages.unshift({ role: item.kind, text, createdAt: item.createdAt });
+        characters += text.length;
+        truncated ||= message.truncated || text.length < message.text.length;
+    }
+    return { messages, truncated };
+};
+/* A sub-agent's replies sit in the thread too, and belong to its own conversation rather than the chat's. */
+export const recentChatMessages = (items, order, limit) => recentMessages(order.map((id) => items[id]).filter((item) => isMessage(item) && !(item.kind === 'assistant' && item.parentToolUseId)), limit);
+/* Everything in a sub-agent's conversation is its own, so nothing is left out for being nested. */
+export const recentSubagentMessages = (items, limit) => recentMessages(items.filter(isMessage), limit);

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

@@ -0,0 +1,3 @@
+import { type ChatScope } from '../scope';
+export declare const useResumeCompactionDismissal: (chatId: string) => string | null;
+export declare const dismissResumeCompaction: (scope: ChatScope, chatId: string, turnId: string) => void;

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

@@ -0,0 +1,14 @@
+import { create } from 'zustand';
+import { useChatScope } from '../scope';
+/*
+ * Which turn a person answered "Keep full history" on, per chat. In memory only: the offer appears
+ * at most once per silence, so a reload asking again costs nothing, and a refusal is not a setting.
+ */
+const useDismissals = create(() => ({ byKey: {} }));
+export const useResumeCompactionDismissal = (chatId) => {
+    const { keyOf } = useChatScope();
+    return useDismissals((s) => s.byKey[keyOf(chatId)] ?? null);
+};
+export const dismissResumeCompaction = (scope, chatId, turnId) => {
+    useDismissals.setState((s) => ({ byKey: { ...s.byKey, [scope.keyOf(chatId)]: turnId } }));
+};

package/dist/chat/runtime-modes.d.ts

@@ -0,0 +1,4 @@
+import { type RuntimeMode } from '@ruimte/agent-contracts';
+export declare const RUNTIME_MODES: readonly RuntimeMode[];
+export declare const runtimeModeLabel: (mode: RuntimeMode) => string;
+export declare const runtimeModeHint: (mode: RuntimeMode) => string;

package/dist/chat/runtime-modes.js

@@ -0,0 +1,11 @@
+import i18next from 'i18next';
+import { RuntimeModeSchema } from '@ruimte/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.
+ */
+export const RUNTIME_MODES = RuntimeModeSchema.options;
+export const runtimeModeLabel = (mode) => i18next.t(`agent-chat:modes.${mode}.label`);
+export const runtimeModeHint = (mode) => i18next.t(`agent-chat:modes.${mode}.hint`);

package/dist/chat/stash.d.ts

@@ -0,0 +1,24 @@
+import { type ChatDraft } from './drafts';
+export declare const STASH_SHORTCUT: import("@ruimte/ui/shortcut").Shortcut;
+export declare const STASH_LIMIT = 20;
+export interface StashedAttachment {
+    name: string;
+    mime: string;
+    size: number;
+}
+export interface StashedPrompt {
+    id: string;
+    text: string;
+    mentions: string[];
+    skills: string[];
+    attachments: StashedAttachment[];
+    createdAt: number;
+}
+export declare const parseStash: (raw: string | null) => StashedPrompt[];
+export declare const withStashed: (prompts: StashedPrompt[], entry: StashedPrompt) => StashedPrompt[];
+export declare const stashedFrom: (draft: ChatDraft, id: string, now: number) => StashedPrompt | null;
+export declare const useStash: import("zustand").UseBoundStore<import("zustand").StoreApi<{
+    prompts: StashedPrompt[];
+}>>;
+export declare const stashDraft: (draft: ChatDraft) => boolean;
+export declare const forgetStashed: (id: string) => void;

package/dist/chat/stash.js

@@ -0,0 +1,88 @@
+import { create } from 'zustand';
+import { uploadBytes } from './attachments';
+import { isEmptyDraft } from './drafts';
+import { isRecord } from './logic/json';
+import { persistedJson } from './persisted-json';
+import { withQuote } from './quote';
+import { shortcut } from '@ruimte/ui/shortcut';
+/* Puts the draft away, or takes the last one back on an empty box. */
+export const STASH_SHORTCUT = shortcut('Mod+S');
+const STORAGE_KEY = 'ruimte.chat.stash';
+// Past this the list is an archive nobody reads; the oldest entry makes room for a new one.
+export const STASH_LIMIT = 20;
+const strings = (value) => (Array.isArray(value) ? value.filter((entry) => typeof entry === 'string') : []);
+const attachments = (value) => {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value.filter(isRecord).map((entry) => ({
+        name: typeof entry.name === 'string' ? entry.name : '',
+        mime: typeof entry.mime === 'string' ? entry.mime : '',
+        size: typeof entry.size === 'number' ? entry.size : 0
+    }));
+};
+/* Only the fields we know today, so anything an older or a broken write left behind falls away here. */
+export const parseStash = (raw) => {
+    if (raw === null) {
+        return [];
+    }
+    try {
+        const stored = JSON.parse(raw);
+        if (!Array.isArray(stored)) {
+            return [];
+        }
+        return stored
+            .filter(isRecord)
+            .filter((entry) => typeof entry.id === 'string' && typeof entry.text === 'string')
+            .map((entry) => ({
+            id: entry.id,
+            text: entry.text,
+            mentions: strings(entry.mentions),
+            skills: strings(entry.skills),
+            attachments: attachments(entry.attachments),
+            createdAt: typeof entry.createdAt === 'number' ? entry.createdAt : 0
+        }))
+            .slice(0, STASH_LIMIT);
+    }
+    catch {
+        return [];
+    }
+};
+/* Newest first, capped: the entry that has been waiting longest is the one nobody comes back for. */
+export const withStashed = (prompts, entry) => [entry, ...prompts].slice(0, STASH_LIMIT);
+/* What a draft looks like on the shelf, its quote folded into the text; null when there is nothing worth putting there. */
+export const stashedFrom = (draft, id, now) => {
+    if (isEmptyDraft(draft)) {
+        return null;
+    }
+    return {
+        id,
+        text: withQuote(draft.quote, draft.text),
+        mentions: [...draft.mentions],
+        skills: [...draft.skills],
+        attachments: draft.attachments.map((attachment) => ({ name: attachment.name, mime: attachment.mime, size: uploadBytes(attachment) })),
+        createdAt: now
+    };
+};
+const storage = persistedJson(STORAGE_KEY, parseStash, []);
+/*
+ * Prompts put aside for later, one list for the whole app rather than one per chat: on a canvas a
+ * stashed prompt usually moves to another node, which is the reason to stash it at all.
+ */
+export const useStash = create(() => ({ prompts: storage.read() }));
+const write = (prompts) => {
+    useStash.setState({ prompts });
+    storage.write(prompts);
+};
+/* Puts a draft on the shelf; false when the composer held nothing to put there. */
+export const stashDraft = (draft) => {
+    const entry = stashedFrom(draft, `stash-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`, Date.now());
+    if (!entry) {
+        return false;
+    }
+    write(withStashed(useStash.getState().prompts, entry));
+    return true;
+};
+export const forgetStashed = (id) => {
+    write(useStash.getState().prompts.filter((entry) => entry.id !== id));
+};

package/dist/chat/subagent-conversation.d.ts

@@ -0,0 +1,38 @@
+import type { ChatItem } from '@ruimte/agent-contracts';
+import { type ChatTransport } from '../transport';
+export declare const SUBAGENT_PAGE = 60;
+export interface SubagentConversationState {
+    status: 'loading' | 'ready' | 'failed';
+    items: ChatItem[];
+    cursor: string | null;
+    live: boolean;
+    loadingEarlier: boolean;
+    error: string | null;
+    unsupported: boolean;
+}
+export declare const INITIAL_CONVERSATION: SubagentConversationState;
+export declare const mergeNewest: (current: ChatItem[], currentCursor: string | null, page: ChatItem[], pageCursor: string | null) => {
+    items: ChatItem[];
+    cursor: string | null;
+};
+export declare class SubagentConversation {
+    private readonly transport;
+    private readonly chatId;
+    private readonly toolUseId;
+    private readonly onChange;
+    private readonly unsubscribe;
+    private state;
+    private disposed;
+    private queue;
+    private refreshWaiting;
+    constructor(transport: ChatTransport, chatId: string, toolUseId: string, onChange: (state: SubagentConversationState) => void);
+    get current(): SubagentConversationState;
+    start(): Promise<void>;
+    refresh(): Promise<void>;
+    loadEarlier(): Promise<void>;
+    dispose(): void;
+    private readNewest;
+    private ask;
+    private enqueue;
+    private set;
+}