@ruimte/agents-react 0.0.0 → 0.7.0

package/LICENSE

@@ -0,0 +1,110 @@
+# Functional Source License, Version 1.1, MIT Future License
+
+## Abbreviation
+
+FSL-1.1-MIT
+
+## Notice
+
+Copyright 2026 Bas Milius
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the MIT license that is effective on the second anniversary of the date we make
+the Software available. On or after that date, you may use the Software under
+the MIT license, in which case the following will apply:
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,144 @@
 # @ruimte/agents-react
 
-Ruimte's AI chat interface for React: the thread, composer and prompt cards, the providers pane and the usage page. This version is a placeholder; install a release.
+Ruimte's AI chat for any React app that runs agent CLIs: the thread and its composer, the approval and question cards, the model and mode pickers, the providers settings pane and the usage page. React 19, Base UI, zustand, react-i18next and Tailwind 4, on top of `@ruimte/ui` and `@ruimte/agent-contracts`.
+
+Import per file, the way `@ruimte/ui` does: `@ruimte/agents-react/chat/ui/Timeline`, `@ruimte/agents-react/transport`.
+
+## The seams
+
+- **`ChatTransport`** (`transport`) is how the chat reaches whatever runs the chats: a typed request out of `AGENT_REQUEST_SCHEMAS` with its typed answer, the events of `AGENT_EVENT_SCHEMAS`, and the status of the link. A link that comes back counts as a fresh one: the chat asks `chat.list` again and attaches every open chat. `portTransport(port)` (`port-transport`) runs one over a `FramePort` of `@ruimte/agent-contracts/port`; its `close()` fails what still waits. A refusal carries a `code` (`errorCode`, `isConnectionError`).
+- **`ChatScope`** (`scope`) is one host of chats as everything under `ChatScopeContext` sees it: an `id` for the stores that keep a row per host (providers, accounts, usage), `keyOf` and `owns` for the rows of the chats store, whose keys the app decides, the `transport`, and the `ChatClient` on it. An app with several hosts renders a scope per host; the usage page renders the host it shows as a scope of its own.
+- **`setChatHost`** (`host`) hands over, once and before the first render, what only the app decides: its palette for account colors, toasts, its own actions (else every action is a request on the transport), file search for `@`, attached files, code themes, how replies stream, file links, find in a thread, dictation, prompts of its own beside a chat's, other chats to point at, the places of forks, tasks, confirmations, logins, project marks, and which settings section to open. Whatever an app leaves out is the chat without that part.
+- **`setLazyPrefetch`** (`lazy`) hands the modules the chat loads lazily (the diff renderers) to the app's prefetcher.
+
+## Wiring it up
+
+In the process that runs the chats, the host answers `AGENT_REQUEST_SCHEMAS` on a `MessagePort`. In the window:
+
+```tsx
+import i18next from 'i18next';
+import { ChatClient } from '@ruimte/agents-react/chat/chat-client';
+import { portTransport } from '@ruimte/agents-react/port-transport';
+import { ChatScopeContext, type ChatScope } from '@ruimte/agents-react/scope';
+import { chatSink } from '@ruimte/agents-react/state/chats';
+import { providerSinkFor } from '@ruimte/agents-react/state/providers';
+import { watchProviderAccounts } from '@ruimte/agents-react/state/provider-accounts';
+import { setChatHost } from '@ruimte/agents-react/host';
+import { AGENTS_LOCALES } from '@ruimte/agents-react/locales';
+import { setFormatSource } from '@ruimte/ui/format/locale';
+import { FORMAT_LANGUAGE } from '@ruimte/ui/format/regions';
+import { UI_LOCALES, UI_NAMESPACE } from '@ruimte/ui/locales';
+
+// The port the utility process handed over, as the frames the chat speaks.
+const transport = portTransport({
+    send: (frame) => port.postMessage(frame),
+    onFrame: (listener) => {
+        const onMessage = (event: MessageEvent) => listener(event.data);
+        port.addEventListener('message', onMessage);
+        port.start();
+        return () => port.removeEventListener('message', onMessage);
+    }
+});
+
+// One host, so a chat's own id is its key.
+const scope: ChatScope = {
+    id: 'local',
+    keyOf: (chatId) => chatId,
+    owns: () => true,
+    transport,
+    chats: new ChatClient(transport, chatSink((chatId) => chatId), providerSinkFor('local'))
+};
+watchProviderAccounts(scope.id, transport);
+
+setFormatSource({
+    language: () => i18next.language,
+    region: () => FORMAT_LANGUAGE,
+    subscribe: (onChange) => {
+        i18next.on('languageChanged', onChange);
+        return () => i18next.off('languageChanged', onChange);
+    }
+});
+setChatHost({ notify: (toast) => showToast(toast), openSettings: (section) => openSettings(section) });
+
+// The words: the ui namespace and the chat's own, in the language on screen.
+i18next.addResourceBundle(language, UI_NAMESPACE, (await UI_LOCALES[language]!()).default, true, true);
+for (const [namespace, words] of Object.entries(await AGENTS_LOCALES[language]!())) {
+    i18next.addResourceBundle(language, namespace, words, true, true);
+}
+```
+
+A chat, opened while it is on screen:
+
+```tsx
+import { useEffect } from 'react';
+import DiffPool from '@ruimte/agents-react/chat/ui/DiffPool';
+import { Composer } from '@ruimte/agents-react/chat/ui/Composer';
+import { Timeline } from '@ruimte/agents-react/chat/ui/Timeline';
+import { useChatRow } from '@ruimte/agents-react/state/chats';
+import DiffWorker from '@pierre/diffs/worker/worker.js?worker';
+
+function Chat({ chatId }: { chatId: string }) {
+    const info = useChatRow(chatId, (row) => row?.info);
+    useEffect(() => {
+        void scope.chats.open(chatId, { cwd: projectFolder });
+        return () => void scope.chats.detach(chatId);
+    }, [chatId]);
+    return (
+        <DiffPool workerFactory={() => new DiffWorker()}>
+            <Timeline
+                chatId={chatId}
+                composer={
+                    info && (
+                        <Composer
+                            chatId={chatId}
+                            info={info}
+                            focused
+                            disabled={transport.status !== 'open'}
+                            providerFixed={false}
+                            onSend={(text, extras) => void scope.chats.send(chatId, text, extras)}
+                            onRetarget={(provider, selection) => void scope.chats.retarget(chatId, provider, selection)}
+                        />
+                    )
+                }
+            />
+        </DiffPool>
+    );
+}
+
+<ChatScopeContext.Provider value={scope}>
+    <Chat chatId="chat-1" />
+</ChatScopeContext.Provider>;
+```
+
+The stylesheet goes right after the ui theme, and Tailwind scans both packages. The markdown of a thread builds on the typography plugin, and a few rules read the terminal colors (`--term-bg`, `--term-fg`, `--term-green`, `--term-red`) and the find colors (`--find-current`) an app defines:
+
+```css
+@import "tailwindcss";
+@import "@ruimte/ui/theme.css";
+@import "@ruimte/agents-react/theme.css";
+@source "<path to>/@ruimte/ui/src";
+@source "<path to>/@ruimte/agents-react/src";
+@plugin "@tailwindcss/typography";
+```
+
+## Settings and usage
+
+`settings/sections` describes the two sections this package brings to the settings dialog of `@ruimte/ui`; `settingsSection` makes the entry the dialog takes, with the pane the app hands it:
+
+```tsx
+import { ProvidersPane } from '@ruimte/agents-react/providers/ProvidersPane';
+import { PROVIDERS_SECTION, USAGE_SECTION, settingsSection } from '@ruimte/agents-react/settings/sections';
+import { UsagePane } from '@ruimte/agents-react/usage/UsagePane';
+import { SettingsDialog } from '@ruimte/ui/settings/SettingsDialog';
+
+<SettingsDialog
+    groups={[{ label: null, sections: [settingsSection(PROVIDERS_SECTION, ProvidersPane), settingsSection(USAGE_SECTION, () => <UsagePane onOpenPage={openUsage} />)] }]}
+    {...rest}
+/>;
+```
+
+`ProvidersPane` takes the `target` a search result leads to and `detailOf`, for a provider the app draws itself. The usage page is `UsageDialog` around `UsagePage`, with an `ErrorBoundary` between them; `pickers` and `notice` take what the app says about the host itself. `UsageLimitsCard` draws the plan windows of the scope's host behind a trigger of the app's.
+
+## Rules
+
+Nothing in `src` imports from an app or from `@ruimte/contracts` (`boundary.test.ts`), and every source file is exported under its own path. The words are the namespaces of `AGENTS_NAMESPACES`, English and Dutch, held against each other by `locales.test.ts`.

package/dist/agents/AccountDot.d.ts

@@ -0,0 +1,4 @@
+export declare function AccountDot({ color, className }: {
+    color: string | undefined;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/agents/AccountDot.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import clsx from 'clsx';
+import { accountColor } from './accounts';
+/* The color an account wears, or the app's accent while it wears none of the accents. */
+export function AccountDot({ color, className }) {
+    const paint = accountColor(color);
+    return (_jsx("span", { "aria-hidden": true, className: clsx('shrink-0 rounded-full', paint === undefined && 'bg-accent', className ?? 'size-2'), style: paint === undefined ? undefined : { background: paint } }));
+}

package/dist/agents/AgentIcon.d.ts

@@ -0,0 +1,6 @@
+import type { AgentKind } from '@ruimte/agent-contracts';
+export declare function AgentIcon({ kind, size, className }: {
+    kind: AgentKind;
+    size?: number;
+    className?: string;
+}): import("react").JSX.Element;

package/dist/agents/AgentIcon.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import clsx from 'clsx';
+import { Bot } from 'lucide-react';
+import { siClaude, siGithubcopilot, siGooglegemini } from 'simple-icons';
+import { Icon } from '@ruimte/ui/Icon';
+import { PROVIDER_PATHS } from './provider-paths';
+// simple-icons removed OpenAI's mark at its request, so Codex reuses the usage page's path.
+const MARKS = {
+    claude: siClaude,
+    codex: { title: 'Codex', path: PROVIDER_PATHS.codex },
+    gemini: siGooglegemini,
+    copilot: siGithubcopilot
+};
+export function AgentIcon({ kind, size = 14, className }) {
+    const mark = MARKS[kind];
+    if (!mark) {
+        return _jsx(Icon, { icon: Bot, size: size, className: className });
+    }
+    return (_jsx("svg", { role: "img", "aria-label": mark.title, viewBox: "0 0 24 24", width: size, height: size, fill: "currentColor", className: clsx('align-middle', className), children: _jsx("path", { d: mark.path }) }));
+}

package/dist/agents/ProviderLogo.d.ts

@@ -0,0 +1,8 @@
+import type { UsageProvider } from '@ruimte/agent-contracts';
+interface ProviderLogoProps {
+    provider: UsageProvider;
+    size?: number;
+    className?: string;
+}
+export declare function ProviderLogo({ provider, size, className }: ProviderLogoProps): import("react").JSX.Element;
+export {};

package/dist/agents/ProviderLogo.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import clsx from 'clsx';
+import { PROVIDER_PATHS } from './provider-paths';
+/* The 24 by 24 box both marks are drawn in, so one size renders them at the same weight. */
+const VIEW_BOX = '0 0 24 24';
+export function ProviderLogo({ provider, size = 14, className }) {
+    return (_jsx("svg", { "aria-hidden": true, viewBox: VIEW_BOX, width: size, height: size, fill: "currentColor", className: clsx('shrink-0', className), children: _jsx("path", { d: PROVIDER_PATHS[provider] }) }));
+}

package/dist/agents/account-limits.d.ts

@@ -0,0 +1,7 @@
+import type { AgentKind, ProviderAccounts, UsageLimitsProvider, UsageLimitsSnapshot, UsageWindow } from '@ruimte/agent-contracts';
+import { type AccountEntry } from './accounts';
+export declare const limitsAccountId: (entry: UsageLimitsProvider) => string;
+export declare const limitsOfAccount: (snapshot: UsageLimitsSnapshot | null, id: string) => UsageLimitsProvider | null;
+export declare const sessionWindow: (entry: UsageLimitsProvider | null) => UsageWindow | null;
+export declare const continueTarget: (accounts: ProviderAccounts | null, snapshot: UsageLimitsSnapshot | null, kind: AgentKind, current: string | undefined) => AccountEntry | null;
+export declare const hasUnreadAccount: (accounts: ProviderAccounts | null, snapshot: UsageLimitsSnapshot | null, kind: AgentKind, current: string | undefined) => boolean;

package/dist/agents/account-limits.js

@@ -0,0 +1,26 @@
+import { accountsOfKind } from './accounts';
+/* The account a plan entry is of; an entry from a machine before accounts is its CLI's default account. */
+export const limitsAccountId = (entry) => entry.account?.id ?? entry.kind;
+export const limitsOfAccount = (snapshot, id) => snapshot?.providers.find((entry) => limitsAccountId(entry) === id) ?? null;
+export const sessionWindow = (entry) => entry?.windows.find((window) => window.kind === 'session') ?? null;
+/* The numbers were read, and no window of the plan is spent. An account never read has no known room. */
+const hasRoom = (entry) => entry !== null && entry.checkedAt > 0 && entry.unavailable === null && entry.windows.length > 0 && entry.windows.every((window) => window.used < 1);
+/* What a turn of this account would run into first: its session window, else its fullest one. */
+const pressure = (entry) => sessionWindow(entry)?.used ?? Math.max(...entry.windows.map((window) => window.used));
+/* The other accounts of the CLI a chat could go on under right now: on, and signed in. */
+const others = (accounts, kind, current) => accountsOfKind(accounts, kind).filter((entry) => entry.id !== (current ?? kind) && entry.account.enabled !== false && entry.status?.state === 'ready');
+/*
+ * The account a chat that stopped on a limit could go on under: another one of its CLI that is on,
+ * signed in and has room, the one with the least of its session spent. Null when none has room, or
+ * none was read yet; the choice is only ever offered, never made.
+ */
+export const continueTarget = (accounts, snapshot, kind, current) => {
+    const roomy = others(accounts, kind, current).flatMap((entry) => {
+        const limits = limitsOfAccount(snapshot, entry.id);
+        return hasRoom(limits) ? [{ entry, pressure: pressure(limits) }] : [];
+    });
+    roomy.sort((a, b) => a.pressure - b.pressure);
+    return roomy[0]?.entry ?? null;
+};
+/* Whether another account a chat could go on under has no numbers yet, since the machine only reads one in use by itself. */
+export const hasUnreadAccount = (accounts, snapshot, kind, current) => others(accounts, kind, current).some((entry) => (limitsOfAccount(snapshot, entry.id)?.checkedAt ?? 0) === 0);

package/dist/agents/accounts.d.ts

@@ -0,0 +1,22 @@
+import type { AgentKind, ProviderAccount, ProviderAccounts, ProviderAccountStatus } from '@ruimte/agent-contracts';
+export declare const accountColor: (color: string | undefined) => string | undefined;
+export declare const FOLDER_VARIABLES: Partial<Record<AgentKind, string>>;
+export interface AccountEntry {
+    id: string;
+    account: ProviderAccount;
+    status: ProviderAccountStatus | null;
+    isDefault: boolean;
+}
+export declare const accountsOfKind: (accounts: ProviderAccounts | null, kind: AgentKind) => AccountEntry[];
+export declare const accountName: (entry: Pick<AccountEntry, 'id' | 'account' | 'isDefault'>, providerName: string) => string;
+export type AccountTone = 'muted' | 'needs-you' | 'error';
+export declare const ACCOUNT_TONE_CLASSES: Record<AccountTone, string>;
+export declare const accountStatusLine: (status: ProviderAccountStatus | null, canLogIn: boolean) => {
+    text: string;
+    tone: AccountTone;
+};
+export declare const mintAccountId: (kind: AgentKind, label: string, taken: ReadonlySet<string>) => string;
+export declare const freeAccountColor: (entries: readonly AccountEntry[], fallback: string) => string;
+export declare const offeredAccounts: (entries: readonly AccountEntry[], current: string | undefined) => AccountEntry[];
+export declare const hasAccountChoice: (entries: readonly AccountEntry[]) => boolean;
+export declare const canContinueOn: (accounts: ProviderAccounts | null, kind: AgentKind, from: string | undefined, to: string | undefined) => boolean;

package/dist/agents/accounts.js

@@ -0,0 +1,103 @@
+import i18next from 'i18next';
+import { chatHost } from '../host';
+/*
+ * An account wears one of the host's accents, so the app paints from one palette. A color that is none
+ * of them (an older name, or one written by hand) reads as undefined, and the dot takes the accent.
+ */
+export const accountColor = (color) => chatHost().accents.all.find((entry) => entry.id === color)?.color;
+/*
+ * The variable each CLI reads its config folder from, as the host's providers name them. Only for
+ * the sentence under the folder; a CLI missing here still works, the sentence just does not name it.
+ */
+export const FOLDER_VARIABLES = { claude: 'CLAUDE_CONFIG_DIR', codex: 'CODEX_HOME' };
+/* The accounts of one CLI, its default one first and the others in the order the machine keeps them. */
+export const accountsOfKind = (accounts, kind) => {
+    if (accounts === null) {
+        return [];
+    }
+    const statuses = new Map(accounts.statuses.map((status) => [status.id, status]));
+    return Object.entries(accounts.accounts)
+        .filter(([, account]) => account.kind === kind)
+        .map(([id, account]) => ({ id, account, status: statuses.get(id) ?? null, isDefault: id === kind }))
+        .sort((a, b) => Number(b.isDefault) - Number(a.isDefault));
+};
+/* A default account nobody named goes by its CLI's name. */
+export const accountName = (entry, providerName) => entry.account.label ?? (entry.isDefault ? providerName : entry.id);
+export const ACCOUNT_TONE_CLASSES = {
+    muted: 'text-text-muted',
+    'needs-you': 'text-status-needs-you',
+    error: 'text-status-error'
+};
+/*
+ * What an account's row says about it, in a few words. `canLogIn` is false for a CLI without a config
+ * folder: it has no login of its own to report, so being there is all a ready one says.
+ */
+export const accountStatusLine = (status, canLogIn) => {
+    const words = (key, values) => i18next.t(`agent-providers:status.${key}`, values);
+    switch (status?.state ?? 'checking') {
+        case 'checking':
+            return { text: words('checking'), tone: 'muted' };
+        case 'disabled':
+            return { text: words('disabled'), tone: 'muted' };
+        case 'not-found':
+            return { text: words('notFound'), tone: 'muted' };
+        case 'signed-out':
+            return { text: words('signedOut'), tone: 'needs-you' };
+        case 'ready':
+            if (!canLogIn) {
+                return { text: words('available'), tone: 'muted' };
+            }
+            return { text: status?.plan ? words('readyPlan', { plan: status.plan }) : words('ready'), tone: 'muted' };
+        case 'folder-missing':
+            return { text: words('folderMissing'), tone: 'error' };
+        case 'unavailable':
+            return { text: words('unavailable'), tone: 'muted' };
+        case 'failed':
+            return { text: words('failed'), tone: 'error' };
+    }
+};
+/* The part of a name an id can hold, the way the machine makes one: `Work (EU)` becomes `work-eu`. */
+const slugOf = (label) => label
+    .normalize('NFKD')
+    .replace(/[̀-ͯ]/g, '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+/* A free id for an account a person links to a folder of their own; one the machine makes gets its id from the machine. */
+export const mintAccountId = (kind, label, taken) => {
+    const base = `${kind}_${slugOf(label) || 'account'}`.slice(0, 60).replace(/-+$/, '');
+    let id = base;
+    for (let suffix = 2; taken.has(id); suffix += 1) {
+        id = `${base}-${suffix}`;
+    }
+    return id;
+};
+/*
+ * The first featured accent no account of the CLI wears yet, then any other, so a new one stands apart.
+ * An account without a color of its own wears `fallback`, the accent the app is painted in.
+ */
+export const freeAccountColor = (entries, fallback) => {
+    const { all, featured } = chatHost().accents;
+    const worn = new Set(entries.map((entry) => (accountColor(entry.account.color) === undefined ? fallback : entry.account.color)));
+    const choices = [...featured, ...all.map((entry) => entry.id).filter((id) => !featured.includes(id))];
+    return choices.find((id) => !worn.has(id)) ?? featured[entries.length % featured.length] ?? fallback;
+};
+/* The accounts of a CLI a picker offers: every one that is on, and the one in use even while it is off. */
+export const offeredAccounts = (entries, current) => entries.filter((entry) => entry.account.enabled !== false || entry.id === current);
+/* Whether a person has a choice of account for this CLI at all, which is when a chat shows its account. */
+export const hasAccountChoice = (entries) => entries.filter((entry) => entry.account.enabled !== false).length >= 2;
+/*
+ * Whether a chat of one account can go on under another, the way the machine decides it: the same
+ * account, or two of the chat's CLI that write their conversations to one folder. A machine that does
+ * not say where an account writes them answers no, so the person forks instead of being refused.
+ */
+export const canContinueOn = (accounts, kind, from, to) => {
+    const fromId = from ?? kind;
+    const toId = to ?? kind;
+    if (fromId === toId) {
+        return true;
+    }
+    const folderOf = (id) => accounts?.accounts[id]?.kind === kind ? accounts.statuses.find((status) => status.id === id)?.transcripts : undefined;
+    const folder = folderOf(fromId);
+    return folder !== undefined && folder !== '' && folder === folderOf(toId);
+};

package/dist/agents/model-name.d.ts

@@ -0,0 +1,6 @@
+import type { AgentKind, ModelInfo } from '@ruimte/agent-contracts';
+export declare const modelNameFromSlug: (slug: string) => string;
+export declare const modelName: (slug: string, models: readonly ModelInfo[] | undefined) => string;
+export declare const useModelName: (provider: AgentKind | undefined, slug: string) => string;
+export declare const sharedModelPrefix: (models: readonly ModelInfo[]) => string;
+export declare const shortModelName: (name: string, models: readonly ModelInfo[] | undefined) => string;

package/dist/agents/model-name.js

@@ -0,0 +1,44 @@
+import { useProviders } from '../state/providers';
+/*
+ * A model id as a person reads it, for a model no catalog names: without its vendor prefix and its
+ * date, and with the version number put back together (`claude-opus-4-5` is one 4.5, not a 4 and a
+ * 5).
+ */
+export const modelNameFromSlug = (slug) => {
+    const bare = slug.slice(slug.lastIndexOf('/') + 1).replace(/-\d{6,8}$/, '');
+    const words = [];
+    for (const word of bare.split('-')) {
+        const previous = words.at(-1);
+        if (previous !== undefined && /^\d+$/.test(word) && /\d$/.test(previous)) {
+            words[words.length - 1] = `${previous}.${word}`;
+            continue;
+        }
+        words.push(word);
+    }
+    return words.map((word) => (word === 'gpt' ? 'GPT' : word.charAt(0).toUpperCase() + word.slice(1))).join(' ');
+};
+/* What the CLI calls the model, so every surface says the same thing; a slug it no longer offers is read as one. */
+export const modelName = (slug, models) => models?.find((entry) => entry.slug === slug)?.name ?? modelNameFromSlug(slug);
+/* The same answer for the machine in scope, whose catalog is the only one that can name the slug. */
+export const useModelName = (provider, slug) => useProviders((state) => modelName(slug, state.providers.find((entry) => entry.kind === provider)?.models));
+/*
+ * The leading words every model of a catalog shares, so a tight spot can say `Opus 5.5` where the
+ * CLI says `Claude Opus 5.5`. Whole words only, so `GPT-6` never loses its `GPT-`, and never all of a name.
+ */
+export const sharedModelPrefix = (models) => {
+    const names = models.map((entry) => entry.name.split(' '));
+    const first = names[0];
+    if (first === undefined || names.length < 2) {
+        return '';
+    }
+    let count = 0;
+    while (names.every((words) => words.length > count + 1 && words[count] === first[count])) {
+        count++;
+    }
+    return count === 0 ? '' : `${first.slice(0, count).join(' ')} `;
+};
+/* A model's name without the words its whole catalog shares. */
+export const shortModelName = (name, models) => {
+    const prefix = sharedModelPrefix(models ?? []);
+    return prefix !== '' && name.startsWith(prefix) ? name.slice(prefix.length) : name;
+};

package/dist/agents/provider-paths.d.ts

@@ -0,0 +1,2 @@
+import type { UsageProvider } from '@ruimte/agent-contracts';
+export declare const PROVIDER_PATHS: Record<UsageProvider, string>;

package/dist/agents/provider-paths.js

@@ -0,0 +1,8 @@
+/*
+ * The marks of Anthropic and OpenAI. Lucide has no brand marks, so these are the icon rule's
+ * exception for provider marks. One path each, in `currentColor`, so a row decides how loud the logo is.
+ */
+export const PROVIDER_PATHS = {
+    claude: 'M4.709 15.955l4.72-2.647.079-.23-.08-.128H9.2l-.79-.048-2.698-.073-2.339-.097-2.266-.122-.571-.121L0 11.784l.055-.352.48-.321.686.06 1.52.103 2.278.158 1.652.097 2.449.255h.389l.055-.157-.134-.098-.103-.097-2.358-1.596-2.552-1.688-1.336-.972-.724-.491-.364-.462-.158-1.008.656-.722.881.06.225.061.893.686 1.908 1.476 2.491 1.833.365.304.145-.103.019-.073-.164-.274-1.355-2.446-1.446-2.49-.644-1.032-.17-.619a2.97 2.97 0 01-.104-.729L6.283.134 6.696 0l.996.134.42.364.62 1.414 1.002 2.229 1.555 3.03.456.898.243.832.091.255h.158V9.01l.128-1.706.237-2.095.23-2.695.08-.76.377-.91.747-.492.584.28.48.685-.067.444-.286 1.851-.559 2.903-.364 1.942h.212l.243-.242.985-1.306 1.652-2.064.73-.82.85-.904.547-.431h1.033l.76 1.129-.34 1.166-1.064 1.347-.881 1.142-1.264 1.7-.79 1.36.073.11.188-.02 2.856-.606 1.543-.28 1.841-.315.833.388.091.395-.328.807-1.969.486-2.309.462-3.439.813-.042.03.048.061 1.549.146.662.036h1.622l3.02.225.79.522.474.638-.079.485-1.215.62-1.64-.389-3.829-.91-1.312-.329h-.182v.11l1.093 1.068 2.006 1.81 2.509 2.33.127.578-.322.455-.34-.049-2.205-1.657-.851-.747-1.926-1.62h-.128v.17l.444.649 2.345 3.521.122 1.08-.17.353-.607.212-.668-.122-1.374-1.925-1.415-2.167-1.143-1.943-.14.08-.674 7.254-.316.37-.729.28-.607-.461-.322-.747.322-1.476.389-1.924.315-1.53.286-1.9.17-.632-.012-.042-.14.018-1.434 1.967-2.18 2.945-1.726 1.845-.414.164-.717-.37.067-.662.401-.589 2.388-3.036 1.44-1.882.93-1.086-.006-.158h-.055L4.132 18.56l-1.13.146-.487-.456.061-.746.231-.243 1.914-1.316-.012.01z',
+    codex: 'M21.55 10.004a5.416 5.416 0 00-.478-4.501c-1.217-2.09-3.662-3.166-6.05-2.66A5.59 5.59 0 0010.831 1C8.39.995 6.224 2.546 5.473 4.838A5.553 5.553 0 001.76 7.496a5.487 5.487 0 00.691 6.5 5.416 5.416 0 00.477 4.502c1.217 2.09 3.662 3.165 6.05 2.66A5.586 5.586 0 0013.168 23c2.443.006 4.61-1.546 5.361-3.84a5.554 5.554 0 003.715-2.66 5.488 5.488 0 00-.693-6.497v.001zm-8.381 11.558a4.199 4.199 0 01-2.675-.954c.034-.018.093-.05.132-.074l4.44-2.53a.71.71 0 00.364-.623v-6.176l1.877 1.069c.02.01.033.029.036.05v5.115c-.003 2.274-1.87 4.118-4.174 4.123zM4.192 17.78a4.059 4.059 0 01-.498-2.763c.032.019.09.055.131.078l4.44 2.53c.225.13.504.13.73 0l5.42-3.088v2.138a.068.068 0 01-.027.057L9.9 19.288c-1.999 1.136-4.552.46-5.707-1.51h-.001zM3.023 8.216A4.15 4.15 0 015.198 6.41l-.002.151v5.06a.711.711 0 00.364.624l5.42 3.087-1.876 1.07a.067.067 0 01-.063.005l-4.489-2.559c-1.995-1.14-2.679-3.658-1.53-5.63h.001zm15.417 3.54l-5.42-3.088L14.896 7.6a.067.067 0 01.063-.006l4.489 2.557c1.998 1.14 2.683 3.662 1.529 5.633a4.163 4.163 0 01-2.174 1.807V12.38a.71.71 0 00-.363-.623zm1.867-2.773a6.04 6.04 0 00-.132-.078l-4.44-2.53a.731.731 0 00-.729 0l-5.42 3.088V7.325a.068.068 0 01.027-.057L14.1 4.713c2-1.137 4.555-.46 5.707 1.513.487.833.664 1.809.499 2.757h.001zm-11.741 3.81l-1.877-1.068a.065.065 0 01-.036-.051V6.559c.001-2.277 1.873-4.122 4.181-4.12.976 0 1.92.338 2.671.954-.034.018-.092.05-.131.073l-4.44 2.53a.71.71 0 00-.365.623l-.003 6.173v.001zm1.02-2.168L12 9.25l2.414 1.375v2.75L12 14.75l-2.415-1.375v-2.75z'
+};

package/dist/agents/status-look.d.ts

@@ -0,0 +1,13 @@
+import { type LucideIcon } from 'lucide-react';
+export type StatusWord = 'running' | 'paused' | 'done' | 'failed' | 'cancelled';
+export interface StatusLook {
+    icon: LucideIcon;
+    tone: string;
+    spins: boolean;
+}
+export declare const statusLookOf: (word: StatusWord) => StatusLook;
+export interface TaskState {
+    status: 'open' | 'done' | 'failed' | 'cancelled';
+    paused?: object;
+}
+export declare const taskStatusWord: (task: TaskState) => StatusWord;

package/dist/agents/status-look.js

@@ -0,0 +1,22 @@
+import { CircleCheck, CircleSlash, CircleX, Hourglass, LoaderCircle } from 'lucide-react';
+/*
+ * One state, one mark: an entry in the sub-agent flyout, a task on its node (`TaskMark`), what finished
+ * in the toolbar (`StatusSummary`) and work in progress in a toast. A spinner stops under reduced
+ * motion with every other animation (`styles.css`).
+ */
+const LOOKS = {
+    running: { icon: LoaderCircle, tone: 'text-status-running', spins: true },
+    // The hourglass of a chat that stopped on a limit, since that is what holds the work up.
+    paused: { icon: Hourglass, tone: 'text-text-faint', spins: false },
+    done: { icon: CircleCheck, tone: 'text-status-idle', spins: false },
+    failed: { icon: CircleX, tone: 'text-status-error', spins: false },
+    cancelled: { icon: CircleSlash, tone: 'text-text-faint', spins: false }
+};
+export const statusLookOf = (word) => LOOKS[word];
+/* A task calls its running state `open`, which is the host's word for it and not a person's; an open task whose child stopped on a limit is paused. */
+export const taskStatusWord = (task) => {
+    if (task.status !== 'open') {
+        return task.status;
+    }
+    return task.paused === undefined ? 'running' : 'paused';
+};

package/dist/chat/account-choice.d.ts

@@ -0,0 +1,11 @@
+import type { AgentKind, ProviderAccounts } from '@ruimte/agent-contracts';
+import { type AccountEntry } from '../agents/accounts';
+export interface AccountChoice {
+    accounts: ProviderAccounts;
+    offered: AccountEntry[];
+    currentId: string;
+    current: AccountEntry | null;
+    providerName: string;
+    nameOf(entry: AccountEntry): string;
+}
+export declare const useAccountChoice: (kind: AgentKind | null, account: string | undefined) => AccountChoice | null;

package/dist/chat/account-choice.js

@@ -0,0 +1,30 @@
+import { useMemo } from 'react';
+import { accountName, accountsOfKind, hasAccountChoice, offeredAccounts } from '../agents/accounts';
+import { useProviderAccounts } from '../state/provider-accounts';
+import { useProviders } from '../state/providers';
+/*
+ * The accounts of a chat's CLI on the machine in scope and the one the chat runs under, or null while
+ * the CLI has fewer than two accounts that are on: with one there is nothing to choose or tell apart.
+ */
+export const useAccountChoice = (kind, account) => {
+    const accounts = useProviderAccounts((row) => row.accounts);
+    const providerName = useProviders((row) => row.providers.find((entry) => entry.kind === kind)?.name) ?? kind ?? '';
+    return useMemo(() => {
+        if (kind === null || accounts === null) {
+            return null;
+        }
+        const entries = accountsOfKind(accounts, kind);
+        if (!hasAccountChoice(entries)) {
+            return null;
+        }
+        const currentId = account ?? kind;
+        return {
+            accounts,
+            offered: offeredAccounts(entries, currentId),
+            currentId,
+            current: entries.find((entry) => entry.id === currentId) ?? null,
+            providerName,
+            nameOf: (entry) => accountName(entry, providerName)
+        };
+    }, [accounts, kind, account, providerName]);
+};

package/dist/chat/actions.d.ts

@@ -0,0 +1,6 @@
+import { type ChatActions } from '../host';
+import { type ChatScope } from '../scope';
+import { type ChatTransport } from '../transport';
+export declare const transportActions: (transport: ChatTransport) => ChatActions;
+export declare const actionsOf: (scope: ChatScope) => ChatActions;
+export declare const useChatActions: () => ChatActions;