@ruimte/agents-react 0.0.0 → 0.7.0

package/dist/chat/ui/rows/WorkRows.js

@@ -0,0 +1,143 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Suspense, useEffect, useState } from 'react';
+import clsx from 'clsx';
+import i18next from 'i18next';
+import { useTranslation } from 'react-i18next';
+import { ChevronRight, FileDiff, X } from 'lucide-react';
+import { fileChanges, liveOutput, readImagePath, toolStartedAt, toolSummary, unifiedChanges } from '../../logic/tools';
+import { useOpenForFind } from '../find-reveal';
+import { chatHost } from '../../../host';
+import { lazyNamed } from '../../../lazy';
+import { useChatActions } from '../../actions';
+import { formatClockDuration, formatElapsedShort } from '@ruimte/ui/format/duration';
+import { ROW_GUTTER, toolIcon } from '../icons';
+import { Icon } from '@ruimte/ui/Icon';
+import { useTickingText } from '@ruimte/ui/useNow';
+// The diff renderers carry shiki; they only load once a thread shows a file change.
+const EditDiff = lazyNamed(() => import('../EditDiff'), 'default');
+const UnifiedDiff = lazyNamed(() => import('../UnifiedDiff'), 'default');
+const OUTPUT_LIMIT = 4000;
+const clip = (text) => text.length > OUTPUT_LIMIT ? `${text.slice(0, OUTPUT_LIMIT)}\n${i18next.t('agent-chat:work.moreCharacters', { count: text.length - OUTPUT_LIMIT })}` : text;
+export function ToggleLine({ icon, label, detail, open, onToggle, failed, live, trailing, className }) {
+    return (_jsxs("button", { className: clsx(
+        // Fix the width so long commands reach the truncation inside the negative margins.
+        '-mx-1 mb-0.5 flex h-7 w-[calc(100%+8px)] items-center gap-2 rounded-md px-1 text-left text-xs text-text-muted hover:bg-surface-hover', failed && 'text-status-error', className), onClick: onToggle, children: [_jsx("span", { className: clsx(ROW_GUTTER, live && 'text-accent'), children: icon }), _jsx("span", { className: clsx('shrink-0', live && 'chat-live-text'), children: label }), detail && (_jsx("span", { "data-find-field": "summary", className: "min-w-0 truncate font-mono text-text-faint", children: detail })), _jsx("span", { className: "grow" }), trailing, failed && _jsx(Icon, { icon: X, size: 12, className: "shrink-0" }), _jsx(Icon, { icon: ChevronRight, size: 12, className: clsx('shrink-0 text-text-faint transition-transform', open && 'rotate-90') })] }));
+}
+function ToolBody({ tool }) {
+    const { t } = useTranslation('agent-chat');
+    const patches = unifiedChanges(tool);
+    const changes = patches.length > 0 ? [] : fileChanges(tool.name, tool.input);
+    return (_jsxs("div", { className: "mt-1.5 mb-2 ml-6 overflow-hidden rounded-md border border-border bg-surface-raised", children: [patches.length > 0 ? (_jsx(Suspense, { fallback: _jsx("div", { className: "px-3 py-2 text-xs text-text-faint", children: t('work.loadingDiff') }), children: patches.map((change, index) => (_jsx(UnifiedDiff, { change: change }, index))) })) : changes.length > 0 ? (_jsx(Suspense, { fallback: _jsx("div", { className: "px-3 py-2 text-xs text-text-faint", children: t('work.loadingDiff') }), children: changes.map((change, index) => (_jsx(EditDiff, { change: change }, index))) })) : (_jsx("pre", { className: "max-h-64 overflow-auto px-3 py-2 font-mono text-code text-text-muted select-text", children: clip(JSON.stringify(tool.input, null, 2) ?? '') })), tool.output !== null && tool.output !== '' && patches.length === 0 && (_jsx("pre", { "data-find-field": "output", className: clsx('max-h-64 overflow-auto whitespace-pre-wrap border-t border-border px-3 py-2 font-mono text-code select-text', tool.state === 'error' ? 'text-term-red' : 'text-term-fg'), children: clip(tool.output) }))] }));
+}
+/* One settled tool call: a line, and its input and output behind it. An image the call looked at
+   is drawn under the line, because a picture says more about that read than its path does. */
+export function WorkRow({ tool, nested, detail }) {
+    const [open, setOpen] = useState(false);
+    const image = tool.state === 'done' ? readImagePath(tool.name, tool.input) : null;
+    const { ReadImage } = chatHost();
+    useOpenForFind(tool.id, 'output', setOpen);
+    return (_jsxs("div", { "data-find-item": tool.id, className: nested ? 'ml-6' : undefined, children: [_jsx(ToggleLine, { icon: toolIcon(tool.name), label: tool.name, detail: detail ?? toolSummary(tool.name, tool.input), open: open, onToggle: () => setOpen((o) => !o), failed: tool.state === 'error' }), image !== null && ReadImage !== null && _jsx(ReadImage, { path: image }), open && _jsx(ToolBody, { tool: tool })] }));
+}
+/* "running for 12s" next to a live call. */
+export function RunningFor({ startedAt }) {
+    const { t } = useTranslation('agent-chat');
+    const ref = useTickingText(() => t('work.runningFor', { elapsed: formatElapsedShort(Date.now() - startedAt) }));
+    return _jsx("span", { ref: ref, className: "shrink-0 text-xs text-text-faint tabular-nums" });
+}
+/* A call still running: its timer on the line, and for a provider that streams output, the last lines under it. */
+export function WorkLiveRow({ tool }) {
+    const [open, setOpen] = useState(false);
+    const tail = liveOutput(tool);
+    return (_jsxs("div", { children: [_jsx(ToggleLine, { icon: toolIcon(tool.name), label: tool.name, detail: toolSummary(tool.name, tool.input) || tool.progress?.description || '', open: open, onToggle: () => setOpen((o) => !o), trailing: _jsx(RunningFor, { startedAt: toolStartedAt(tool) }), live: true }), open && _jsx(ToolBody, { tool: tool }), tail !== null && !open && (_jsx("pre", { className: "mt-1.5 mb-2 ml-6 max-h-48 overflow-auto rounded-md border border-border bg-surface-raised px-3 py-2 font-mono text-code whitespace-pre-wrap text-term-fg select-text", children: tail }))] }));
+}
+/* A run of tool calls as one line ("Read 4 files"); opening it lists every call. */
+export function WorkGroupRow({ tools, summary, expanded, onToggle }) {
+    const failed = tools.some((tool) => tool.state === 'error');
+    return (_jsx("div", { children: _jsx(ToggleLine, { icon: toolIcon(tools[0].name), label: summary, open: expanded, onToggle: onToggle, failed: failed }) }));
+}
+/*
+ * A settled turn folded behind how long it took and what it did. A line and not a button, like the
+ * tool lines it hides; the work reads fainter than the time so the eye lands on the time first.
+ */
+export function TurnFoldRow({ turn, label, work, expanded, onToggle }) {
+    return (_jsxs("button", { className: clsx('group -mx-1 mb-2 flex h-7 w-[calc(100%+8px)] min-w-0 items-center gap-2 rounded-md px-1 text-left text-xs text-text-muted hover:bg-surface-hover', turn.state === 'error' && 'text-status-error'), "aria-expanded": expanded, onClick: onToggle, children: [_jsx("span", { className: ROW_GUTTER, children: _jsx(Icon, { icon: ChevronRight, size: 12, className: clsx('transition-transform', expanded && 'rotate-90') }) }), _jsx("span", { className: "shrink-0 group-hover:text-text", children: label }), work.length > 0 && _jsx("span", { className: "min-w-0 truncate text-text-faint", children: work.map((part) => ` · ${part}`).join('') })] }));
+}
+const omittedLabel = (reason) => reason === 'binary' ? i18next.t('agent-chat:work.omitted.binary') : i18next.t('agent-chat:work.omitted.tooLarge');
+/* One file of a turn's checkpoint diff: its patch, or the reason there is none. */
+function CheckpointFileBody({ file }) {
+    const { t } = useTranslation('agent-chat');
+    if (file.omitted) {
+        return _jsx("div", { className: "px-3 py-2 text-xs text-text-faint", children: omittedLabel(file.omitted) });
+    }
+    return (_jsx(Suspense, { fallback: _jsx("div", { className: "px-3 py-2 text-xs text-text-faint", children: t('work.loadingDiff') }), children: _jsx(UnifiedDiff, { change: file }) }));
+}
+/*
+ * The files a settled turn changed, as a card; each file opens its diff in place. The host's
+ * checkpoint diff comes first (the working tree against the tree the turn started from), then the
+ * unified diffs the CLI reported, then the before and after of its own edits. A turn that has a
+ * checkpoint but no stored diff asks the host for one, which is also how a running turn gets it.
+ */
+export function ChangedFilesRow({ tools, diff, checkpoint, chatId, turnId }) {
+    const { t } = useTranslation('agent-chat');
+    const [open, setOpen] = useState({});
+    const [fetched, setFetched] = useState(null);
+    const actions = useChatActions();
+    useEffect(() => {
+        if (diff !== null || !checkpoint) {
+            return;
+        }
+        let alive = true;
+        void actions
+            .turnDiff(chatId, turnId)
+            .then((answer) => {
+            if (alive) {
+                setFetched(answer);
+            }
+        })
+            .catch(() => undefined);
+        return () => {
+            alive = false;
+        };
+    }, [actions, chatId, turnId, diff, checkpoint]);
+    const checkpointDiff = diff ?? fetched;
+    if (checkpointDiff !== null && checkpointDiff.files.length > 0) {
+        return (_jsxs("div", { className: "mb-3 overflow-hidden rounded-lg border border-border bg-surface-raised", children: [_jsxs("div", { className: "flex items-center gap-2 px-3 py-2 text-xs text-text-muted", children: [_jsx(Icon, { icon: FileDiff, size: 12 }), _jsx("span", { className: "font-medium text-text", children: t('work.changedFiles', { count: checkpointDiff.files.length }) }), checkpointDiff.truncated && _jsx("span", { className: "text-text-faint", children: t('work.andMore') })] }), checkpointDiff.files.map((file) => (_jsxs("div", { className: "border-t border-border", children: [_jsxs("button", { className: "flex w-full items-center gap-2 px-3 py-1.5 text-left text-xs text-text-muted hover:bg-surface-hover", "data-file-path": file.path, onClick: () => setOpen((o) => ({ ...o, [file.path]: !o[file.path] })), children: [_jsx(Icon, { icon: ChevronRight, size: 12, className: clsx('shrink-0 text-text-faint transition-transform', open[file.path] && 'rotate-90') }), _jsx("span", { className: "min-w-0 truncate font-mono text-text", children: file.path }), _jsx("span", { className: "grow" }), _jsxs("span", { className: "text-term-green tabular-nums", children: ["+", file.added] }), _jsxs("span", { className: "text-term-red tabular-nums", children: ["-", file.deleted] })] }), open[file.path] && (_jsx("div", { className: "border-t border-border", children: _jsx(CheckpointFileBody, { file: file }) }))] }, file.path)))] }));
+    }
+    return _jsx(ProviderChangedFiles, { tools: tools, open: open, setOpen: setOpen });
+}
+/* The fallback card, built from what the CLI itself reported about its edits. */
+function ProviderChangedFiles({ tools, open, setOpen }) {
+    const { t } = useTranslation('agent-chat');
+    const byPath = new Map();
+    const entryFor = (path) => {
+        const existing = byPath.get(path);
+        if (existing) {
+            return existing;
+        }
+        const created = { edits: [], patches: [] };
+        byPath.set(path, created);
+        return created;
+    };
+    for (const tool of tools) {
+        const patches = unifiedChanges(tool);
+        if (patches.length > 0) {
+            for (const patch of patches) {
+                entryFor(patch.path).patches.push(patch);
+            }
+            continue;
+        }
+        for (const change of fileChanges(tool.name, tool.input)) {
+            entryFor(change.path || tool.id).edits.push(change);
+        }
+    }
+    return (_jsxs("div", { className: "mb-3 overflow-hidden rounded-lg border border-border bg-surface-raised", children: [_jsxs("div", { className: "flex items-center gap-2 px-3 py-2 text-xs text-text-muted", children: [_jsx(Icon, { icon: FileDiff, size: 12 }), _jsx("span", { className: "font-medium text-text", children: t('work.changedFiles', { count: byPath.size }) })] }), [...byPath].map(([path, entry]) => {
+                const count = entry.edits.length + entry.patches.length;
+                return (_jsxs("div", { className: "border-t border-border", children: [_jsxs("button", { className: "flex w-full items-center gap-2 px-3 py-1.5 text-left text-xs text-text-muted hover:bg-surface-hover", "data-file-path": path, onClick: () => setOpen((o) => ({ ...o, [path]: !o[path] })), children: [_jsx(Icon, { icon: ChevronRight, size: 12, className: clsx('shrink-0 text-text-faint transition-transform', open[path] && 'rotate-90') }), _jsx("span", { className: "min-w-0 truncate font-mono text-text", children: path }), _jsx("span", { className: "grow" }), _jsx("span", { className: "text-text-faint", children: t('work.edits', { count }) })] }), open[path] && (_jsx("div", { className: "border-t border-border", children: _jsxs(Suspense, { fallback: _jsx("div", { className: "px-3 py-2 text-xs text-text-faint", children: t('work.loadingDiff') }), children: [entry.patches.map((change, index) => (_jsx(UnifiedDiff, { change: change }, `patch-${index}`))), entry.edits.map((change, index) => (_jsx(EditDiff, { change: change }, `edit-${index}`)))] }) }))] }, path));
+            })] }));
+}
+/* "Working for 00:14". */
+export function WorkingRow({ startedAt }) {
+    const { t } = useTranslation('agent-chat');
+    const ref = useTickingText(() => formatClockDuration(Date.now() - startedAt));
+    return (_jsxs("div", { className: "-mx-1 mb-0.5 flex h-7 items-center gap-2 px-1 text-xs text-text-muted", children: [_jsx("span", { className: `${ROW_GUTTER} text-accent`, children: _jsx("span", { className: "h-2 w-2 rounded-full bg-status-running" }) }), _jsx("span", { className: "chat-live-text", children: t('work.workingFor') }), _jsx("span", { ref: ref, className: "tabular-nums" })] }));
+}

package/dist/chat/ui/rows/WorkflowRow.d.ts

@@ -0,0 +1,7 @@
+import { type ChatToolItem, type ChatWorkflow } from '@ruimte/agent-contracts';
+import type { SubagentStep } from '../../subagent-view';
+export declare function WorkflowRow({ tool, workflow, onOpenAgent }: {
+    tool: ChatToolItem;
+    workflow: ChatWorkflow;
+    onOpenAgent?(step: SubagentStep): void;
+}): import("react").JSX.Element;

package/dist/chat/ui/rows/WorkflowRow.js

@@ -0,0 +1,37 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useTranslation } from 'react-i18next';
+import { Bot, ListTree } from 'lucide-react';
+import { workflowAgentRef } from '@ruimte/agent-contracts';
+import { workflowAgentTime, workflowPhases } from '../../logic/workflow';
+import { useSubagentSupport } from '../../subagent-support';
+import { ROW_GUTTER } from '../icons';
+import { RunningFor, ToggleLine, WorkLiveRow, WorkRow } from './WorkRows';
+import { useChatScope } from '../../../scope';
+import { Icon } from '@ruimte/ui/Icon';
+function AgentLine({ view, onOpen }) {
+    const { agent, state } = view;
+    const time = workflowAgentTime(view);
+    const running = state === 'running';
+    const agentId = agent.agentId;
+    // One still waiting has no transcript yet.
+    const open = onOpen !== undefined && agentId !== null ? () => onOpen({ toolUseId: workflowAgentRef(agentId), description: agent.label }) : () => undefined;
+    return (_jsx(ToggleLine, { icon: _jsx(Icon, { icon: Bot, size: 12 }), label: agent.label, detail: running ? (agent.lastTool ?? undefined) : undefined, open: false, onToggle: open, failed: state === 'failed', live: running, trailing: running && agent.startedAt !== null ? (_jsx(RunningFor, { startedAt: agent.startedAt })) : (_jsx("span", { className: "shrink-0 text-xs text-text-faint tabular-nums", children: time })) }));
+}
+function PhaseBlock({ phase, onOpen }) {
+    const { t } = useTranslation('agent-chat');
+    return (_jsxs("div", { children: [phase.title !== null && (_jsxs("div", { className: "mb-0.5 flex h-7 min-w-0 items-center gap-2 text-xs text-text-muted", children: [_jsx("span", { className: ROW_GUTTER, children: _jsx(Icon, { icon: ListTree, size: 12 }) }), _jsx("span", { className: "min-w-0 truncate", children: phase.title }), _jsx("span", { className: "grow" }), phase.agents.length === 0 && _jsx("span", { className: "shrink-0 text-text-faint", children: t('rows.workflow.notStarted') })] })), phase.agents.length > 0 && (_jsx("div", { className: phase.title === null ? undefined : 'ml-6', children: phase.agents.map((view) => (_jsx(AgentLine, { view: view, onOpen: onOpen }, view.agent.index))) }))] }));
+}
+/*
+ * A Workflow call with the phases its script announced under it, and in each phase the agents it
+ * started, in the style of the agents a sub-agent opened. They stay in sight whether the call's own
+ * body is open or not; pressing an agent opens its conversation, read from its run's folder.
+ */
+export function WorkflowRow({ tool, workflow, onOpenAgent }) {
+    const { id } = useChatScope();
+    // A host that does not answer `chat.subagent` has no conversation to open for anyone.
+    const refused = useSubagentSupport((s) => s.unsupported[id] === true);
+    const running = tool.state === 'running';
+    const phases = workflowPhases(workflow, running);
+    const onOpen = refused ? undefined : onOpenAgent;
+    return (_jsxs("div", { children: [running ? _jsx(WorkLiveRow, { tool: tool }) : _jsx(WorkRow, { tool: tool, detail: workflow.name ?? undefined }), phases.length > 0 && (_jsx("div", { className: "ml-6", children: phases.map((phase) => (_jsx(PhaseBlock, { phase: phase, onOpen: onOpen }, phase.key))) }))] }));
+}

package/dist/chat/ui/rows/row-rhythm.d.ts

@@ -0,0 +1,3 @@
+import { type TimelineRow } from '../../logic/timeline';
+export declare const FOLLOW_THRESHOLD_PX = 40;
+export declare const rowRhythm: (row: TimelineRow, previous: TimelineRow | null) => string;

package/dist/chat/ui/rows/row-rhythm.js

@@ -0,0 +1,14 @@
+import clsx from 'clsx';
+import { isBlock } from '../../logic/timeline';
+/* Below this distance from the bottom a thread follows what the agent writes; above it the reader scrolled back on purpose. */
+export const FOLLOW_THRESHOLD_PX = 40;
+/*
+ * The gaps a row wears for where it sits: a question is followed by its answer gap, and a seam where
+ * the list rhythm of tool lines meets the block rhythm of prose gets the block gap. A question
+ * already carries the gap before it, and the row after one is the answer, so neither takes a seam.
+ */
+export const rowRhythm = (row, previous) => {
+    const question = row.kind === 'user';
+    const seam = !question && previous !== null && previous.kind !== 'user' && isBlock(row) !== isBlock(previous);
+    return clsx(question && 'pb-(--chat-answer-gap)', seam && 'pt-(--chat-block-gap)');
+};

package/dist/chat/ui/useToggleSet.d.ts

@@ -0,0 +1,6 @@
+export interface ToggleSet {
+    ids: ReadonlySet<string>;
+    toggle(id: string): void;
+    add(id: string): void;
+}
+export declare const useToggleSet: (onToggle?: () => void) => ToggleSet;

package/dist/chat/ui/useToggleSet.js

@@ -0,0 +1,25 @@
+import { useCallback, useState } from 'react';
+/*
+ * The ids of the folds a thread has open. `onToggle` is what a thread does about a person opening
+ * one, which is to stop following the end: a fold is a deliberate look back, not a reason to jump.
+ */
+export const useToggleSet = (onToggle) => {
+    const [ids, setIds] = useState(() => new Set());
+    const toggle = useCallback((id) => {
+        setIds((current) => {
+            const next = new Set(current);
+            if (next.has(id)) {
+                next.delete(id);
+            }
+            else {
+                next.add(id);
+            }
+            return next;
+        });
+        onToggle?.();
+    }, [onToggle]);
+    const add = useCallback((id) => {
+        setIds((current) => new Set(current).add(id));
+    }, []);
+    return { ids, toggle, add };
+};

package/dist/host.d.ts

@@ -0,0 +1,167 @@
+import type { ComponentProps, ComponentType, ReactNode, RefObject } from 'react';
+import type { Extension } from '@codemirror/state';
+import type { EditorView } from '@codemirror/view';
+import type { ThemeRegistration } from 'shiki';
+import type { AgentKind, ChatCheckpointDiff, ChatConfigurePayload, ChatItem } from '@ruimte/agent-contracts';
+import type { TimelineRow } from './chat/logic/timeline';
+import type { FindReveal } from './chat/ui/find-reveal';
+import type { PromptAction } from './prompts/logic/prompts';
+import type { HostPrompt, PromptViewProps } from './prompts/logic/subjects';
+export interface AccentChoice {
+    id: string;
+    color: string;
+}
+export interface ChatToast {
+    id?: string;
+    title: string;
+    description?: string;
+    kind: 'success' | 'error' | 'deleted';
+    action?: {
+        label: string;
+        run(): void;
+    };
+}
+export interface ChatActions {
+    clear(chatId: string, force: boolean): Promise<void>;
+    stopTurn(chatId: string, subagents: boolean): Promise<void>;
+    unqueue(chatId: string, messageId: string): Promise<void>;
+    sendNow(chatId: string, messageId: string): Promise<void>;
+    compact(chatId: string): Promise<void>;
+    configure(chatId: string, patch: Omit<ChatConfigurePayload, 'chatId'>): Promise<void>;
+    continueOn(chatId: string, account: string): Promise<void>;
+    turnDiff(chatId: string, turnId: string): Promise<ChatCheckpointDiff | null>;
+    stopSubagent(chatId: string, toolUseId: string): Promise<void>;
+    stopTask(chatId: string, taskId: string): Promise<void>;
+    approve(chatId: string, requestId: string, decision: 'allow' | 'allow-always' | 'deny', message?: string): Promise<void>;
+    answer(chatId: string, requestId: string, answers: Record<string, string>): Promise<void>;
+    dismiss(chatId: string, itemId: string): Promise<void>;
+}
+export interface FileRef {
+    path: string;
+    line?: number;
+    directory: boolean;
+}
+export interface ChatPlace {
+    title: string | null;
+    go(): void;
+}
+export interface SubagentTask {
+    status: 'open' | 'done' | 'failed' | 'cancelled';
+    createdAt: number;
+    settledAt: number | null;
+    paused?: {
+        until?: number;
+    };
+}
+export interface TimelineFindOptions {
+    chatId: string;
+    frame: RefObject<HTMLDivElement | null>;
+    thread: RefObject<HTMLDivElement | null>;
+    scroller: RefObject<HTMLDivElement | null>;
+    enabled: boolean;
+    rows: readonly TimelineRow[];
+    structure: Readonly<Record<string, ChatItem>> | undefined;
+    order: readonly string[] | undefined;
+    firstRowInView(): number;
+    openTurn(turnId: string): void;
+    openGroup(id: string): void;
+    openSubagent(id: string): void;
+    scrollToRow(index: number): void;
+    coveredHeight(): number;
+    stopFollowing(): void;
+}
+export interface TimelineFind {
+    open: boolean;
+    bar: ReactNode;
+    reveal: FindReveal | null;
+    hitRows: readonly number[];
+    currentRow: number | null;
+}
+export interface ComposerDictationProps {
+    targetRef: RefObject<HTMLElement | null>;
+    buttonContainer: HTMLElement | null | undefined;
+    disabled: boolean;
+    editor(): EditorView | null;
+}
+export type TextareaProps = ComponentProps<'textarea'> & {
+    buttonClassName?: string;
+};
+export interface ResourceUrl {
+    url: string | null;
+    failure: string | null;
+}
+export interface ChatHost {
+    accents: {
+        all: readonly AccentChoice[];
+        featured: readonly string[];
+        label(id: string): string;
+        current(): string;
+    };
+    isApplePlatform(): boolean;
+    isAppShortcut(event: KeyboardEvent): boolean;
+    notify(toast: ChatToast): void;
+    actions: ChatActions | null;
+    searchFiles: ((scopeId: string, cwd: string, query: string, limit: number) => Promise<string[]>) | null;
+    attachments: {
+        useUrl(scopeId: string, chatId: string, attachmentId: string): ResourceUrl;
+        read(scopeId: string, chatId: string, attachmentId: string): Promise<Blob>;
+    };
+    ReadImage: ComponentType<{
+        path: string;
+    }> | null;
+    code: {
+        useMode(): 'light' | 'dark';
+        useThemes(): {
+            light: string;
+            dark: string;
+        };
+        custom: ReadonlyArray<ThemeRegistration & {
+            name: string;
+        }>;
+    };
+    useStreaming(): 'words' | 'blocks' | 'whole';
+    fileLinks: {
+        target(text: string, cwd: string | null): FileRef | null;
+        open(cwd: string | null, ref: FileRef): void;
+    } | null;
+    useTimelineFind(options: TimelineFindOptions): TimelineFind;
+    dictation: {
+        Textarea: ComponentType<TextareaProps>;
+        composer: {
+            extensions: Extension;
+            Control: ComponentType<ComposerDictationProps>;
+        } | null;
+    };
+    prompts: {
+        useExtra(scopeId: string, chatId: string): readonly HostPrompt[];
+        render(prompt: HostPrompt, props: PromptViewProps): ReactNode;
+        answer(prompt: HostPrompt, action: PromptAction): Promise<void>;
+    };
+    useReferableChats(): ReadonlyArray<{
+        id: string;
+        title: string;
+    }>;
+    openLogin: ((scopeId: string, kind: AgentKind, accountId: string, name: string) => Promise<void>) | null;
+    useLoginBlocked(scopeId: string): string | null;
+    useProjectLook(scopeId: string, projectId: string | null): {
+        name: string;
+        mark: ReactNode;
+    } | null;
+    useChatPlace(chatId: string): ChatPlace;
+    useContextSources(chatId: string): ReadonlyArray<{
+        title: string;
+    }>;
+    tasks: {
+        useTasks(scopeId: string): Readonly<Record<string, SubagentTask>> | undefined;
+        useTask(scopeId: string, taskId: string | null): SubagentTask | null;
+    };
+    confirm: {
+        stopSubagents(scopeId: string, chatId: string, run: () => void): void;
+        stopTask(scopeId: string, childId: string, title: string, run: () => void): void;
+    };
+    fork: ((chatId: string, turnId: string) => void) | null;
+    openSettings(section: 'providers' | 'agents'): void;
+    useResumeAtReset(scopeId: string): boolean;
+}
+export declare const setChatHost: (patch: Partial<ChatHost>) => void;
+export declare const chatHost: () => ChatHost;

package/dist/host.js

@@ -0,0 +1,41 @@
+import { isApplePlatform } from '@ruimte/ui/platform';
+import { PlainTextarea } from './ui/PlainTextarea';
+const NO_PROMPTS = [];
+const NO_CHATS = [];
+const NO_ROWS = [];
+const NO_FIND = { open: false, bar: null, reveal: null, hitRows: NO_ROWS, currentRow: null };
+const NO_SOURCES = [];
+const NO_URL = { url: null, failure: null };
+const NOWHERE = { title: null, go: () => undefined };
+const DEFAULT_HOST = {
+    accents: { all: [], featured: [], label: (id) => id, current: () => '' },
+    isApplePlatform,
+    isAppShortcut: () => false,
+    notify: () => undefined,
+    actions: null,
+    searchFiles: null,
+    attachments: { useUrl: () => NO_URL, read: () => Promise.reject(new Error('This app keeps no attached files')) },
+    ReadImage: null,
+    code: { useMode: () => 'light', useThemes: () => ({ light: 'github-light', dark: 'github-dark' }), custom: [] },
+    useStreaming: () => 'words',
+    fileLinks: null,
+    useTimelineFind: () => NO_FIND,
+    dictation: { Textarea: PlainTextarea, composer: null },
+    prompts: { useExtra: () => NO_PROMPTS, render: () => null, answer: () => Promise.reject(new Error('This app raises no prompts of its own')) },
+    useReferableChats: () => NO_CHATS,
+    openLogin: null,
+    useLoginBlocked: () => null,
+    useProjectLook: () => null,
+    useChatPlace: () => NOWHERE,
+    useContextSources: () => NO_SOURCES,
+    tasks: { useTasks: () => undefined, useTask: () => null },
+    confirm: { stopSubagents: (_scopeId, _chatId, run) => run(), stopTask: (_scopeId, _childId, _title, run) => run() },
+    fork: null,
+    openSettings: () => undefined,
+    useResumeAtReset: () => true
+};
+let host = DEFAULT_HOST;
+export const setChatHost = (patch) => {
+    host = { ...host, ...patch };
+};
+export const chatHost = () => host;

package/dist/lazy.d.ts

@@ -0,0 +1,5 @@
+import { type ComponentProps, type ComponentType } from 'react';
+type Loader = () => Promise<unknown>;
+export declare const setLazyPrefetch: (next: (load: Loader) => void) => void;
+export declare function lazyNamed<Module extends Record<Name, ComponentType<any>>, Name extends keyof Module>(load: () => Promise<Module>, name: Name): ComponentType<ComponentProps<Module[Name]>>;
+export {};

package/dist/lazy.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { lazy } from 'react';
+const loaders = [];
+let register = null;
+/*
+ * Hands every module the chat loads lazily to the app's prefetcher: the ones made so far, and each
+ * one made from now on. Without it they load on their first render, as `React.lazy` does.
+ */
+export const setLazyPrefetch = (next) => {
+    register = next;
+    for (const load of loaders) {
+        next(load);
+    }
+};
+/*
+ * `React.lazy` for a module that exports its component by name, `default` included. Once the module
+ * is here the component is drawn straight away, since `React.lazy` suspends for a tick even on a
+ * module the prefetcher already fetched.
+ */
+export function lazyNamed(load, name) {
+    let loaded = null;
+    const open = async () => {
+        const component = (await load())[name];
+        loaded ??= component;
+        return component;
+    };
+    loaders.push(open);
+    register?.(open);
+    const Lazy = lazy(async () => ({ default: await open() }));
+    const LazyNamed = (props) => {
+        const Component = loaded ?? Lazy;
+        return _jsx(Component, { ...props });
+    };
+    return LazyNamed;
+}