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

package/src/chat/quote.ts

@@ -0,0 +1,26 @@
+/*
+ * 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: string): string | null {
+    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: string, message: string): string {
+    if (quote === '') {
+        return message;
+    }
+    const block = quote
+        .split('\n')
+        .map((line) => (line === '' ? '>' : `> ${line}`))
+        .join('\n');
+    return message === '' ? block : `${block}\n\n${message}`;
+}

package/src/chat/recent-messages.ts

@@ -0,0 +1,59 @@
+import type { ChatItem } from '@adecore/agent-contracts';
+
+export interface RecentChatMessage {
+    role: 'user' | 'assistant';
+    text: string;
+    createdAt: number;
+}
+
+export interface RecentChatMessages {
+    messages: RecentChatMessage[];
+    truncated: boolean;
+}
+
+const MAX_TOTAL_CHARACTERS = 12_000;
+const MAX_MESSAGE_CHARACTERS = 3_000;
+
+function clipped(text: string): { text: string; truncated: boolean } {
+    return text.length <= MAX_MESSAGE_CHARACTERS ? { text, truncated: false } : { text: `${text.slice(0, MAX_MESSAGE_CHARACTERS - 1)}…`, truncated: true };
+}
+
+type MessageItem = Extract<ChatItem, { kind: 'user' | 'assistant' }>;
+
+function isMessage(item: ChatItem | undefined): item is MessageItem {
+    return 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 function recentMessages(eligible: readonly MessageItem[], limit: number): RecentChatMessages {
+    const candidates = eligible.slice(-limit);
+    const messages: RecentChatMessage[] = [];
+    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 function recentChatMessages(items: Record<string, ChatItem>, order: readonly string[], limit: number): RecentChatMessages {
+    return recentMessages(
+        order.map((id) => items[id]).filter((item): item is MessageItem => 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 function recentSubagentMessages(items: readonly ChatItem[], limit: number): RecentChatMessages {
+    return recentMessages(items.filter(isMessage), limit);
+}

package/src/chat/resume-compaction-dismissals.ts

@@ -0,0 +1,17 @@
+import { create } from 'zustand';
+import { useChatScope, type ChatScope } 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: Record<string, string> }>(() => ({ byKey: {} }));
+
+export function useResumeCompactionDismissal(chatId: string): string | null {
+    const { keyOf } = useChatScope();
+    return useDismissals((s) => s.byKey[keyOf(chatId)] ?? null);
+}
+
+export function dismissResumeCompaction(scope: ChatScope, chatId: string, turnId: string): void {
+    useDismissals.setState((s) => ({ byKey: { ...s.byKey, [scope.keyOf(chatId)]: turnId } }));
+}

package/src/chat/runtime-modes.ts

@@ -0,0 +1,18 @@
+import i18next from 'i18next';
+import { RuntimeModeSchema, type RuntimeMode } from '@adecore/agent-contracts';
+
+/*
+ * The runtime modes in the order they are offered, shared by the composer's mode picker, the
+ * settings dialog and the agent menus. That order is the schema's, which the host reads as the
+ * rank from narrowest to widest. Only the ids live here: the words are in `modes.<id>` of the `chat`
+ * namespace, read when a surface draws one rather than when this module loads.
+ */
+export const RUNTIME_MODES: readonly RuntimeMode[] = RuntimeModeSchema.options;
+
+export function runtimeModeLabel(mode: RuntimeMode): string {
+    return i18next.t(`agent-chat:modes.${mode}.label`);
+}
+
+export function runtimeModeHint(mode: RuntimeMode): string {
+    return i18next.t(`agent-chat:modes.${mode}.hint`);
+}

package/src/chat/stash.ts

@@ -0,0 +1,122 @@
+import { chatStorageKey, chatStorageLegacyKeys, createChatStore } from '../storage';
+import { uploadBytes } from './attachments';
+import { isEmptyDraft, type ChatDraft } from './drafts';
+import { isRecord } from './logic/json';
+import { persistedJson } from './persisted-json';
+import { withQuote } from './quote';
+import { shortcut } from '@adecore/ui';
+
+/* Puts the draft away, or takes the last one back on an empty box. */
+export const STASH_SHORTCUT = shortcut('Mod+S');
+
+const storageKey = (): string => chatStorageKey('stash');
+
+// Past this the list is an archive nobody reads; the oldest entry makes room for a new one.
+export const STASH_LIMIT = 20;
+
+/* What was attached when the prompt was put away. The bytes are not kept, only what they were. */
+export interface StashedAttachment {
+    name: string;
+    mime: string;
+    size: number;
+}
+
+export interface StashedPrompt {
+    id: string;
+    text: string;
+    mentions: string[];
+    skills: string[];
+    attachments: StashedAttachment[];
+    createdAt: number;
+}
+
+function strings(value: unknown): string[] {
+    return Array.isArray(value) ? value.filter((entry): entry is string => typeof entry === 'string') : [];
+}
+
+function attachments(value: unknown): StashedAttachment[] {
+    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 function parseStash(raw: string | null): StashedPrompt[] {
+    if (raw === null) {
+        return [];
+    }
+    try {
+        const stored: unknown = 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 as string,
+                text: entry.text as string,
+                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 function withStashed(prompts: StashedPrompt[], entry: StashedPrompt): StashedPrompt[] {
+    return [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 function stashedFrom(draft: ChatDraft, id: string, now: number): StashedPrompt | null {
+    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<StashedPrompt[]>(storageKey, parseStash, [], () => chatStorageLegacyKeys('stash'));
+
+/*
+ * Prompts put aside for later can move to another chat, so the shelf is shared across chats.
+ */
+export const useStash = createChatStore<{ prompts: StashedPrompt[] }>(
+    () => ({ prompts: [] }),
+    (store) => store.setState({ prompts: storage.read() })
+);
+
+function write(prompts: StashedPrompt[]): void {
+    useStash.setState({ prompts });
+    storage.write(prompts);
+}
+
+/* Puts a draft on the shelf; false when the composer held nothing to put there. */
+export function stashDraft(draft: ChatDraft): boolean {
+    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 function forgetStashed(id: string): void {
+    write(useStash.getState().prompts.filter((entry) => entry.id !== id));
+}

package/src/chat/subagent-conversation.ts

@@ -0,0 +1,203 @@
+import i18next from 'i18next';
+import type { ChatItem, ChatSubagentResult } from '@adecore/agent-contracts';
+import { errorCode, isConnectionError, type ChatTransport } from '../transport';
+
+// What the panel opens on: the newest end of the conversation, which is where an agent that works is.
+export const SUBAGENT_PAGE = 60;
+
+export interface SubagentConversationState {
+    status: 'loading' | 'ready' | 'failed';
+    items: ChatItem[];
+    source: ChatSubagentResult['source'] | null;
+    context: NonNullable<ChatSubagentResult['context']> | null;
+    /* Where the page before the oldest item on screen starts; null once the start is there. */
+    cursor: string | null;
+    live: boolean;
+    loadingEarlier: boolean;
+    /* Why nothing could be read, as the machine said it. */
+    error: string | null;
+    /* The machine answered that it knows no such request, which is a machine from before this panel. */
+    unsupported: boolean;
+}
+
+export const INITIAL_CONVERSATION: SubagentConversationState = {
+    status: 'loading',
+    items: [],
+    source: null,
+    context: null,
+    cursor: null,
+    live: false,
+    loadingEarlier: false,
+    error: null,
+    unsupported: false
+};
+
+/*
+ * The newest page laid over what is on screen. An item that is already there is replaced where it
+ * stands and a new one goes after them all. A page that shares nothing with what is held means more
+ * happened than one page holds, so what is held is dropped for it rather than shown with a hole.
+ */
+export function mergeNewest(
+    current: ChatItem[],
+    currentCursor: string | null,
+    page: ChatItem[],
+    pageCursor: string | null
+): { items: ChatItem[]; cursor: string | null } {
+    const known = new Map(current.map((item, index) => [item.id, index]));
+    if (current.length > 0 && page.length > 0 && !page.some((item) => known.has(item.id))) {
+        return { items: page, cursor: pageCursor };
+    }
+    const items = [...current];
+    for (const item of page) {
+        const index = known.get(item.id);
+        if (index === undefined) {
+            items.push(item);
+        } else {
+            items[index] = item;
+        }
+    }
+    return { items, cursor: current.length === 0 ? pageCursor : currentCursor };
+}
+
+function messageOf(error: unknown): string {
+    return error instanceof Error ? error.message : i18next.t('agent-chat:subagents.noAnswer');
+}
+
+/*
+ * One subagent's conversation as a panel follows it. Opening asks for the newest page and holds the
+ * conversation on the machine, which then says whenever it grew; each time, the newest page is asked
+ * again and laid over what is there. A socket that comes back holds it again, and letting go is the
+ * last thing it says.
+ */
+export class SubagentConversation {
+    private readonly transport: ChatTransport;
+    private readonly chatId: string;
+    private readonly toolUseId: string;
+    private readonly onChange: (state: SubagentConversationState) => void;
+    private readonly unsubscribe: Array<() => void> = [];
+    private state: SubagentConversationState = INITIAL_CONVERSATION;
+    private disposed = false;
+    // One request at a time, so a refresh never lands under an older page that arrived after it.
+    private queue: Promise<void> = Promise.resolve();
+    private refreshWaiting = false;
+    private earlier: Promise<void> | null = null;
+
+    constructor(transport: ChatTransport, chatId: string, toolUseId: string, onChange: (state: SubagentConversationState) => void) {
+        this.transport = transport;
+        this.chatId = chatId;
+        this.toolUseId = toolUseId;
+        this.onChange = onChange;
+    }
+
+    get current(): SubagentConversationState {
+        return this.state;
+    }
+
+    start(): Promise<void> {
+        this.unsubscribe.push(
+            this.transport.on('chat.subagentChanged', (event) => {
+                if (event.chatId === this.chatId && event.toolUseId === this.toolUseId) {
+                    void this.refresh();
+                }
+            }),
+            this.transport.subscribeStatus((status) => {
+                if (status === 'open') {
+                    void this.enqueue(() => this.readNewest(true));
+                }
+            })
+        );
+        return this.enqueue(() => this.readNewest(true));
+    }
+
+    /* The newest page again; calls that arrive while one waits become that one. */
+    refresh(): Promise<void> {
+        if (this.refreshWaiting) {
+            return this.queue;
+        }
+        this.refreshWaiting = true;
+        return this.enqueue(() => {
+            this.refreshWaiting = false;
+            return this.readNewest(false);
+        });
+    }
+
+    loadEarlier(): Promise<void> {
+        // A page on its way answers every call made meanwhile; a scroll asks for one on every frame.
+        this.earlier ??= this.enqueue(async () => {
+            const cursor = this.state.cursor;
+            if (cursor === null) {
+                return;
+            }
+            this.set({ loadingEarlier: true });
+            try {
+                const page = await this.ask({ cursor, limit: SUBAGENT_PAGE });
+                this.set({ items: [...page.items, ...this.state.items], cursor: page.history.cursor, live: page.live, loadingEarlier: false });
+            } catch (error) {
+                if (errorCode(error) === 'history-expired') {
+                    // The record was written again under this panel; what it holds now is the only truth.
+                    this.set({ items: [], cursor: null, loadingEarlier: false });
+                    await this.readNewest(false);
+                    return;
+                }
+                this.set({ loadingEarlier: false, error: messageOf(error) });
+            }
+        }).finally(() => {
+            this.earlier = null;
+        });
+        return this.earlier;
+    }
+
+    dispose(): void {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        for (const off of this.unsubscribe.splice(0)) {
+            off();
+        }
+        if (this.transport.status === 'open') {
+            void this.transport.request('chat.subagent', { chatId: this.chatId, toolUseId: this.toolUseId, limit: 1, watch: false }).catch(() => undefined);
+        }
+    }
+
+    private async readNewest(watch: boolean): Promise<void> {
+        try {
+            const page = await this.ask({ limit: SUBAGENT_PAGE, ...(watch ? { watch: true } : {}) });
+            const merged = mergeNewest(this.state.items, this.state.cursor, page.items, page.history.cursor);
+            this.set({
+                status: 'ready',
+                items: merged.items,
+                cursor: merged.cursor,
+                live: page.live,
+                source: page.source,
+                context: page.context ?? null,
+                error: null
+            });
+        } catch (error) {
+            if (this.state.status === 'ready' && isConnectionError(error)) {
+                // What is on screen stays; the socket that comes back asks again.
+                return;
+            }
+            const unsupported = errorCode(error) === 'unknown-request';
+            this.set({ status: 'failed', error: messageOf(error), unsupported });
+        }
+    }
+
+    private ask(extra: { cursor?: string; limit: number; watch?: boolean }): Promise<ChatSubagentResult> {
+        return this.transport.request('chat.subagent', { chatId: this.chatId, toolUseId: this.toolUseId, ...extra });
+    }
+
+    private enqueue(work: () => Promise<void>): Promise<void> {
+        const next = this.queue.then(() => (this.disposed ? undefined : work()));
+        this.queue = next.catch(() => undefined);
+        return next;
+    }
+
+    private set(patch: Partial<SubagentConversationState>): void {
+        if (this.disposed) {
+            return;
+        }
+        this.state = { ...this.state, ...patch };
+        this.onChange(this.state);
+    }
+}

package/src/chat/subagent-list.ts

@@ -0,0 +1,141 @@
+import i18next from 'i18next';
+import type { ChatInfo, ChatItem, ChatSubagentItem } from '@adecore/agent-contracts';
+import { formatMoment, formatElapsedShort, formatTokens } from '@adecore/ui/format';
+import type { StatusWord } from '../agents/status-look';
+import type { SubagentTask } from '../host';
+
+export function subagentTitle(item: ChatSubagentItem): string {
+    return item.description || item.summary || item.subagentType || i18next.t('agent-chat:rows.subagent.label');
+}
+
+/* What the bar over a sub-agent's conversation says of it beside its state and its time; the model is named by the caller, which has the catalog. */
+export function subagentFacts(item: ChatSubagentItem, modelName: string | null): string[] {
+    return [
+        modelName,
+        item.subagentType,
+        item.background ? i18next.t('agent-chat:rows.subagent.background') : null,
+        item.usage !== null && item.usage.totalTokens > 0
+            ? i18next.t('agent-chat:subagents.info.tokens', { tokens: formatTokens(item.usage.totalTokens) })
+            : null,
+        item.usage !== null && item.usage.toolUses > 0 ? i18next.t('agent-chat:group.toolCalls', { count: item.usage.toolUses }) : null
+    ].filter((fact): fact is string => fact !== null && fact !== '');
+}
+
+/* The task a row stands for, whose id the host wrote into the row's own. */
+export function taskIdOf(item: ChatSubagentItem): string | null {
+    return item.origin === 'ruimte' && item.id.startsWith('task-') ? item.id.slice(5) : null;
+}
+
+/* A cancelled task is a failed row on the wire and a paused one a running row, and only the task itself still says which it is. */
+export function statusWordOf(item: ChatSubagentItem, task: SubagentTask | null): StatusWord {
+    if (item.status === 'failed' && task?.status === 'cancelled') {
+        return 'cancelled';
+    }
+    if (item.status === 'running' && task?.status === 'open' && task.paused !== undefined) {
+        return 'paused';
+    }
+    return item.status;
+}
+
+/* What a task's row says its agent is doing: the task's own state, or that the agent waits on a person while the task runs. */
+export type TaskRowState = StatusWord | 'waiting';
+
+export function taskRowStateOf(item: ChatSubagentItem, task: SubagentTask | null, child: ChatInfo | undefined): TaskRowState {
+    const word = statusWordOf(item, task);
+    if (word === 'running' && (child?.status === 'needs-you' || (child?.requests?.length ?? 0) > 0)) {
+        return 'waiting';
+    }
+    return word;
+}
+
+/*
+ * What the flyout over the composer lists: every sub-agent still at work, and the ones that settled
+ * since the last message, so a finished batch stays until the next message is sent. That includes an
+ * older row a message woke again. A settled one from before that message stays too while a sibling of
+ * its turn still runs. Older ones are only in the thread.
+ */
+export function flyoutSubagents(order: readonly string[], structure: Readonly<Record<string, ChatItem>>): ChatSubagentItem[] {
+    const lastMessage = order.findLastIndex((id) => structure[id]?.kind === 'user');
+    const lastMessageAt = lastMessage < 0 ? null : (structure[order[lastMessage]!]?.createdAt ?? null);
+    const items = order.flatMap((id, index) => {
+        const item = structure[id];
+        return item?.kind === 'subagent' ? [{ item, index }] : [];
+    });
+    const turns = new Set(items.flatMap(({ item }) => (item.status === 'running' && item.turnId !== null ? [item.turnId] : [])));
+    return items
+        .filter(
+            ({ item, index }) =>
+                item.status === 'running' ||
+                index > lastMessage ||
+                (lastMessageAt !== null && item.finishedAt !== null && item.finishedAt > lastMessageAt) ||
+                (item.turnId !== null && turns.has(item.turnId))
+        )
+        .map(({ item }) => item);
+}
+
+/* The one state the badge shows for all of them: work in progress first, then work held up, then whatever went wrong. */
+export function summaryWordOf(words: readonly StatusWord[]): StatusWord {
+    return (['running', 'paused', 'failed', 'cancelled'] as const).find((word) => words.includes(word)) ?? 'done';
+}
+
+/* The number on the badge: the ones still at work, a paused one included, and all of them once none is. */
+export function badgeCountOf(words: readonly StatusWord[]): number {
+    const active = words.filter((word) => word === 'running' || word === 'paused').length;
+    return active > 0 ? active : words.length;
+}
+
+/* The time on the right of an entry: how long it has run so far, or how long it took once it settled. */
+export function entryTimeOf(item: ChatSubagentItem, task: SubagentTask | null, now: number): string {
+    // A task's own record says when it was given and settled; the row copies those, but may lag behind it.
+    const startedAt = task?.createdAt ?? item.startedAt;
+    const finishedAt = task === null ? item.finishedAt : (task.settledAt ?? item.finishedAt);
+    const word = statusWordOf(item, task);
+    if (word === 'paused') {
+        const until = task?.paused?.until;
+        return until === undefined
+            ? i18next.t('agent-chat:common.status.paused')
+            : i18next.t('agent-chat:activity.pausedUntil', { time: formatMoment(until, now) });
+    }
+    if (item.status === 'running') {
+        return startedAt > 0 ? formatElapsedShort(now - startedAt) : '';
+    }
+    if (startedAt <= 0 || finishedAt === null || finishedAt < startedAt) {
+        return i18next.t(`agent-chat:common.status.${word}`);
+    }
+    return i18next.t(`agent-chat:activity.took.${word}`, { duration: formatElapsedShort(finishedAt - startedAt) });
+}
+
+/*
+ * What the Stop of an active entry does: a task stops the node working on it, and a subagent of the
+ * CLI's own is only marked stopped, since no CLI stops one on its own. While the chat's turn runs that
+ * turn may still wait on it, so stopping the turn (the composer's Stop) is the only offer then.
+ */
+export type SubagentStop = 'task' | 'mark';
+
+export function stopOf(item: ChatSubagentItem, turnRunning: boolean): SubagentStop | null {
+    if (item.status !== 'running') {
+        return null;
+    }
+    if (item.origin === 'ruimte') {
+        return item.childId === undefined ? null : 'task';
+    }
+    return turnRunning ? null : 'mark';
+}
+
+export function stopLabel(stop: SubagentStop): string {
+    return stop === 'task' ? i18next.t('agent-chat:subagents.stop.task') : i18next.t('agent-chat:subagents.stop.mark');
+}
+
+/*
+ * What the composer's Stop does. A plain click stops the turn alone, as it always has; Shift also ends
+ * every agent the chat opened and marks its CLI's own sub-agents stopped, which a turn alone leaves running.
+ */
+export type ComposerStop = 'turn' | 'turn-and-subagents';
+
+export function composerStopOf(shiftKey: boolean): ComposerStop {
+    return shiftKey ? 'turn-and-subagents' : 'turn';
+}
+
+export function composerStopLabel(): string {
+    return i18next.t('agent-chat:composer.stop');
+}

package/src/chat/subagent-support.ts

@@ -0,0 +1,21 @@
+import { create } from 'zustand';
+
+interface SubagentSupportStore {
+    /* The hosts, by scope id, that answered that they cannot open a subagent's conversation, for this page's life. */
+    unsupported: Record<string, true>;
+    markUnsupported(scopeId: string): void;
+}
+
+/*
+ * Whether a host can open a subagent's conversation is learned by asking once rather than from a
+ * version: the first refusal hides the button on that host's rows that carry no pointer of their own.
+ */
+export const useSubagentSupport = create<SubagentSupportStore>((set, get) => ({
+    unsupported: {},
+    markUnsupported(scopeId) {
+        if (get().unsupported[scopeId]) {
+            return;
+        }
+        set({ unsupported: { ...get().unsupported, [scopeId]: true } });
+    }
+}));