@hachej/boring-ui-kit 0.4.25 → 0.4.27

package/dist/chat-react-controller.d.ts

@@ -0,0 +1,25 @@
+export type ConversationControllerState<C> = {
+    readonly status: 'connecting';
+} | {
+    readonly status: 'offline';
+    readonly error: unknown;
+} | {
+    readonly status: 'ready';
+    readonly controller: C;
+};
+export interface ControllerPerConversationOptions<C extends {
+    readonly dispose: () => unknown;
+}> {
+    /** Stable selection identity, including source/owner and relevant options. Undefined acquires nothing. */
+    readonly key: unknown;
+    readonly create: () => C | Promise<C>;
+    readonly connect?: ((controller: C) => Promise<void>) | undefined;
+    /** Defaults to the concrete controller's dispose. Must release only resources created by this binding. */
+    readonly dispose?: ((controller: C) => unknown) | undefined;
+    readonly retryMs?: number | undefined;
+}
+/** Owns only the selected adapter, never its borrowed Harness/source. Late acquisitions are released, not published. */
+export declare function useControllerPerConversation<C extends {
+    readonly dispose: () => unknown;
+}>(options: ControllerPerConversationOptions<C>): ConversationControllerState<C>;
+//# sourceMappingURL=chat-react-controller.d.ts.map

package/dist/chat-react-controller.js

@@ -0,0 +1,72 @@
+'use client';
+import { useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+/** Owns only the selected adapter, never its borrowed Harness/source. Late acquisitions are released, not published. */
+export function useControllerPerConversation(options) {
+    const { key, retryMs = 1000 } = options;
+    const binding = useMemo(() => ({ key }), [key, retryMs]);
+    const latest = useRef(options);
+    useLayoutEffect(() => { latest.current = options; });
+    const [stored, setStored] = useState();
+    useEffect(() => {
+        if (key === undefined)
+            return;
+        // Capture ownership callbacks for this selection; later renders must not redirect its teardown.
+        const { create, connect, dispose } = latest.current;
+        let off = false, owned, retiring;
+        let timer, wake;
+        const publish = (state) => { if (!off)
+            setStored({ binding, state }); };
+        const retire = () => {
+            if (retiring)
+                return retiring;
+            const controller = owned;
+            owned = undefined;
+            if (!controller)
+                return Promise.resolve();
+            retiring = Promise.resolve().then(() => dispose ? dispose(controller) : controller.dispose()).then(() => { });
+            return retiring;
+        };
+        void (async () => {
+            while (!off) {
+                try {
+                    owned = await create();
+                    if (off) {
+                        await retire();
+                        return;
+                    }
+                    await connect?.(owned);
+                    if (off) {
+                        await retire();
+                        return;
+                    }
+                    publish({ status: 'ready', controller: owned });
+                    return;
+                }
+                catch (error) {
+                    try {
+                        await retire();
+                    }
+                    catch (teardownError) {
+                        console.error('Chat controller teardown failed', teardownError);
+                    }
+                    retiring = undefined;
+                    if (off)
+                        return;
+                    publish({ status: 'offline', error });
+                    await new Promise(resolve => { wake = resolve; timer = setTimeout(resolve, retryMs); });
+                    wake = undefined;
+                    timer = undefined;
+                }
+            }
+        })();
+        return () => {
+            off = true;
+            if (timer !== undefined)
+                clearTimeout(timer);
+            wake?.();
+            void retire().catch(error => console.error('Chat controller teardown failed', error));
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps -- binding owns the selection; callback identity alone must not reconnect
+    }, [binding, retryMs]);
+    return stored?.binding === binding ? stored.state : { status: 'connecting' };
+}

package/dist/chat-react-conversations.d.ts

@@ -0,0 +1,40 @@
+export interface ConversationItem {
+    readonly id: string;
+    readonly title?: string | undefined;
+    readonly updatedAt?: number | string | Date | undefined;
+    readonly lastMessage?: string | null | undefined;
+    readonly archived?: boolean | undefined;
+}
+/** Headless list/actions; row menus and other presentation extensions stay with the registry. */
+export interface ConversationsClient {
+    readonly items: readonly ConversationItem[];
+    readonly activeId: string | undefined;
+    readonly reload: () => Promise<void>;
+    readonly onSelect: (id: string) => void;
+    readonly onNew: () => void;
+    readonly search: (query: string, options: {
+        readonly archived: boolean;
+    }, signal: AbortSignal) => Promise<readonly ConversationItem[]>;
+    readonly rename: (id: string, title: string) => Promise<void>;
+    readonly archive: (id: string, archived: boolean) => Promise<void>;
+    readonly remove: (id: string) => Promise<void>;
+    readonly fork: (atEntryId: string) => Promise<void>;
+}
+export interface ConversationsClientOptions {
+    readonly endpoint: string | URL | undefined;
+    readonly fetch: (request: Request) => Promise<Response>;
+    readonly activeId: string | undefined;
+    readonly onSelect: (id: string) => void;
+    readonly onChange?: (() => void | Promise<void>) | undefined;
+    readonly pollMs?: number;
+}
+/**
+ * The sessions list over the host's conversations handler (`createConversationsHandler` of `@hachej/boring-agent/conversations`, mounted at
+ * `endpoint`): the active list (polled every `pollMs` while mounted), server-side search with the Archived filter, New, rename, archive,
+ * delete and fork. New and fork select the conversation they made through `onSelect`. `onChange` runs after every change the person made
+ * (the host may reload what depends on the list). `fetch` is the host's authenticated fetch. Returns `undefined` until the first list arrives.
+ */
+export declare function useConversationsClient({ endpoint, fetch, activeId, onSelect, onChange, pollMs }: ConversationsClientOptions): ConversationsClient | undefined;
+/** Compatibility spelling retained for one release. */
+export declare const useConversations: typeof useConversationsClient;
+//# sourceMappingURL=chat-react-conversations.d.ts.map

package/dist/chat-react-conversations.js

@@ -0,0 +1,68 @@
+'use client';
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'react';
+const item = (served) => ({ id: String(served.id), title: served.title ?? undefined, updatedAt: served.updatedAt, lastMessage: served.lastMessage, archived: served.archived });
+/**
+ * The sessions list over the host's conversations handler (`createConversationsHandler` of `@hachej/boring-agent/conversations`, mounted at
+ * `endpoint`): the active list (polled every `pollMs` while mounted), server-side search with the Archived filter, New, rename, archive,
+ * delete and fork. New and fork select the conversation they made through `onSelect`. `onChange` runs after every change the person made
+ * (the host may reload what depends on the list). `fetch` is the host's authenticated fetch. Returns `undefined` until the first list arrives.
+ */
+export function useConversationsClient({ endpoint, fetch, activeId, onSelect, onChange, pollMs = 4000 }) {
+    const [items, setItems] = useState();
+    const latest = useRef({ fetch, onSelect, onChange, activeId });
+    useLayoutEffect(() => { latest.current = { fetch, onSelect, onChange, activeId }; });
+    const base = endpoint === undefined ? undefined : String(endpoint);
+    const call = useCallback(async (params, body, signal) => {
+        if (base === undefined)
+            throw new Error('No conversations endpoint');
+        const url = new URL(base, globalThis.location?.href);
+        for (const [key, value] of Object.entries(params))
+            url.searchParams.set(key, value);
+        const init = body === undefined ? { ...(signal ? { signal } : {}) } : { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body), ...(signal ? { signal } : {}) };
+        const response = await latest.current.fetch(new Request(url, init));
+        if (!response.ok)
+            throw new Error(`Conversations: ${response.status}`);
+        return await response.json();
+    }, [base]);
+    const reload = useCallback(async () => { const result = await call({}); setItems((result.conversations ?? []).map(item)); }, [call]);
+    // Another endpoint (another owner's list) starts empty; switching conversations only reloads.
+    // eslint-disable-next-line react-hooks/set-state-in-effect -- a new endpoint clears the old owner's list once, after commit
+    useEffect(() => { setItems(undefined); }, [base]);
+    useEffect(() => {
+        if (base === undefined)
+            return;
+        let off = false;
+        const load = () => call({}).then(result => { if (!off)
+            setItems((result.conversations ?? []).map(item)); }).catch(() => { });
+        void load();
+        const timer = setInterval(load, pollMs);
+        return () => { off = true; clearInterval(timer); };
+    }, [base, call, pollMs, activeId]);
+    return useMemo(() => {
+        if (!items)
+            return undefined;
+        const changed = async () => { await reload().catch(() => { }); await latest.current.onChange?.(); };
+        const op = (name, body) => call({ op: name }, body);
+        return {
+            items, activeId, reload,
+            onSelect: (id) => latest.current.onSelect(id),
+            onNew: () => { void op('create', {}).then(async (result) => { await changed(); if (result.conversationId !== undefined)
+                latest.current.onSelect(String(result.conversationId)); }).catch(() => { }); },
+            search: async (query, { archived }, signal) => ((await call({ ...(query ? { q: query } : {}), ...(archived ? { archived: '1' } : {}) }, undefined, signal)).conversations ?? []).map(item),
+            rename: async (id, title) => { await op('rename', { conversationId: id, title }); await changed(); },
+            archive: async (id, archived) => { await op('archive', { conversationId: id, archived }); await changed(); },
+            remove: async (id) => { await op('delete', { conversationId: id }); await changed(); },
+            fork: async (at) => {
+                const from = latest.current.activeId;
+                if (from === undefined)
+                    return;
+                const { conversationId } = await op('fork', { conversationId: from, at });
+                await changed();
+                if (conversationId !== undefined)
+                    latest.current.onSelect(String(conversationId));
+            },
+        };
+    }, [items, activeId, call, reload]);
+}
+/** Compatibility spelling retained for one release. */
+export const useConversations = useConversationsClient;

package/dist/chat-react-draft.d.ts

@@ -0,0 +1,11 @@
+import type { ChatController } from './native-chat.js';
+/**
+ * Keeps the composer's half-typed message (the controller's draft) per conversation in localStorage, so it survives a reload and shows in
+ * every tab on the same conversation (the `storage` event). The draft is emptied when a message is sent, and a refused send puts the text back,
+ * which is written again. Without `key` nothing happens. Storage that is missing or throws only means the draft is not kept.
+ *
+ * On mount the conversation's saved draft replaces the composer's text; text already in the composer and not yet saved is written at once.
+ * On a change of `key` (same controller) the composer shows the new conversation's saved draft, or an empty one, so no text moves across.
+ */
+export declare function useChatDraft(controller: ChatController, key: string | undefined): void;
+//# sourceMappingURL=chat-react-draft.d.ts.map

package/dist/chat-react-draft.js

@@ -0,0 +1,91 @@
+'use client';
+import { useEffect, useRef } from 'react';
+const PREFIX = 'pi-chat:draft:';
+/** The stored draft: a string, `null` when the key is missing, `undefined` when storage is unavailable (missing, blocked or throwing). */
+function read(storageKey) {
+    try {
+        const storage = globalThis.localStorage;
+        return storage ? storage.getItem(storageKey) : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function write(storageKey, text) {
+    try {
+        if (text)
+            globalThis.localStorage?.setItem(storageKey, text);
+        else
+            globalThis.localStorage?.removeItem(storageKey);
+    }
+    catch { /* the composer still holds the text */ }
+}
+/**
+ * Keeps the composer's half-typed message (the controller's draft) per conversation in localStorage, so it survives a reload and shows in
+ * every tab on the same conversation (the `storage` event). The draft is emptied when a message is sent, and a refused send puts the text back,
+ * which is written again. Without `key` nothing happens. Storage that is missing or throws only means the draft is not kept.
+ *
+ * On mount the conversation's saved draft replaces the composer's text; text already in the composer and not yet saved is written at once.
+ * On a change of `key` (same controller) the composer shows the new conversation's saved draft, or an empty one, so no text moves across.
+ */
+export function useChatDraft(controller, key) {
+    // The key the hook last loaded; a different key on a later run is a conversation switch, not a first mount.
+    const loaded = useRef(undefined);
+    useEffect(() => {
+        if (key === undefined || controller.getSnapshot().disposed)
+            return;
+        const storageKey = PREFIX + key;
+        const switched = loaded.current !== undefined && loaded.current !== key;
+        loaded.current = key;
+        const stored = read(storageKey);
+        const current = controller.getSnapshot().draft.text;
+        // The text last known to be in storage; a write happens only when the composer's text differs from it.
+        let saved;
+        if (stored) {
+            if (stored !== current)
+                controller.setText(stored);
+            saved = stored;
+        }
+        else if (switched) {
+            // The new conversation has no saved draft (or storage is unavailable): the old conversation's text must not stay.
+            if (current)
+                controller.setText('');
+            saved = '';
+        }
+        else {
+            saved = current;
+            if (stored === null && current)
+                write(storageKey, current);
+        }
+        const persist = () => {
+            if (controller.getSnapshot().disposed)
+                return;
+            const text = controller.getSnapshot().draft.text;
+            if (text === saved)
+                return;
+            saved = text;
+            write(storageKey, text);
+        };
+        const unsubscribe = controller.subscribe(persist);
+        // Another tab changed this conversation's draft (or cleared all storage: `key` is null). Adopting it does not write it back.
+        // Unavailable storage is not a missing draft: the composer keeps its text.
+        const onStorage = (event) => {
+            if (event.key !== null && event.key !== storageKey)
+                return;
+            if (controller.getSnapshot().disposed)
+                return;
+            const next = read(storageKey);
+            if (next === undefined)
+                return;
+            const text = next ?? '';
+            saved = text;
+            if (text !== controller.getSnapshot().draft.text)
+                controller.setText(text);
+        };
+        globalThis.addEventListener?.('storage', onStorage);
+        return () => {
+            unsubscribe();
+            globalThis.removeEventListener?.('storage', onStorage);
+        };
+    }, [controller, key]);
+}

package/dist/chat-react-remote.d.ts

@@ -0,0 +1,33 @@
+import type { ChatController, ChatIdentity, NativeChatController } from './native-chat.js';
+import type { RemoteChat, RemoteChatOptions } from './remote-chat.js';
+export type ChatPlacement = 'docked' | 'floating';
+/** Reports the placement of the chat showing `controller` while the caller is mounted. */
+export declare function useChatPlacement(controller: ChatController, placement: ChatPlacement): void;
+export declare function readChatPlacement(controller: ChatController | undefined): ChatPlacement | undefined;
+export type RemoteChatState = {
+    readonly status: 'connecting';
+    readonly conversationId: string | undefined;
+} | {
+    readonly status: 'offline';
+    readonly conversationId: string | undefined;
+    readonly error: string;
+} | {
+    readonly status: 'ready';
+    readonly conversationId: string;
+    readonly controller: NativeChatController;
+    readonly actions: Partial<Pick<RemoteChat, 'answer' | 'withdraw'>>;
+    readonly configure: RemoteChat['configure'];
+};
+export interface RemoteChatHookOptions {
+    readonly conversationId: string | undefined;
+    readonly endpoint: (conversationId: string) => string | URL;
+    readonly fetch: (request: Request) => Promise<Response>;
+    readonly identity: ChatIdentity | undefined;
+    /** Read at each submit; placement is merged alongside the host's unchanged screen context. Advisory, never authority. */
+    readonly requestContext?: () => Readonly<Record<string, unknown>> | undefined;
+    readonly transport?: RemoteChatOptions['transport'];
+    readonly webSocket?: RemoteChatOptions['webSocket'];
+}
+/** One owned native controller per selection; the remote transport itself reopens dropped streams. Failed acquisition retries each second. */
+export declare function useRemoteChat({ conversationId, endpoint, fetch, identity, requestContext, transport, webSocket }: RemoteChatHookOptions): RemoteChatState;
+//# sourceMappingURL=chat-react-remote.d.ts.map

package/dist/chat-react-remote.js

@@ -0,0 +1,72 @@
+'use client';
+import { useLayoutEffect, useMemo, useRef } from 'react';
+import { createNativeChatController } from './native-chat.js';
+import { createRemoteChat } from './remote-chat.js';
+import { useControllerPerConversation } from './chat-react-controller.js';
+// Keyed by controller (a page can hold several chats; floating or docking keeps the controller, PLACE-3). Each mounted presenter has its own
+// registration, so unmounting one never clears another's; the latest surviving registration wins.
+const placements = new WeakMap();
+/** Reports the placement of the chat showing `controller` while the caller is mounted. */
+export function useChatPlacement(controller, placement) {
+    useLayoutEffect(() => {
+        const entry = { placement };
+        const list = placements.get(controller) ?? [];
+        placements.set(controller, [...list, entry]);
+        return () => {
+            const rest = (placements.get(controller) ?? []).filter(item => item !== entry);
+            if (rest.length)
+                placements.set(controller, rest);
+            else
+                placements.delete(controller);
+        };
+    }, [controller, placement]);
+}
+export function readChatPlacement(controller) {
+    return controller ? placements.get(controller)?.at(-1)?.placement : undefined;
+}
+/** One owned native controller per selection; the remote transport itself reopens dropped streams. Failed acquisition retries each second. */
+export function useRemoteChat({ conversationId, endpoint, fetch, identity, requestContext, transport, webSocket }) {
+    const url = conversationId === undefined ? undefined : String(endpoint(conversationId));
+    const key = identity && conversationId !== undefined ? JSON.stringify([conversationId, url, identity.runtimeId, identity.scopeId, identity.principalId, transport]) : undefined;
+    const latest = useRef({ fetch, requestContext, webSocket });
+    useLayoutEffect(() => { latest.current = { fetch, requestContext, webSocket }; });
+    // Transport ownership stays with the controller that acquired it, including when connect or selection changes race.
+    const remotes = useMemo(() => new WeakMap(), []);
+    const selected = useControllerPerConversation({ key,
+        create: async () => {
+            let controller;
+            const remote = await createRemoteChat({ endpoint: url, fetch: request => latest.current.fetch(request),
+                requestContext: () => {
+                    const placement = readChatPlacement(controller), screen = latest.current.requestContext?.();
+                    return placement || screen ? { ...screen, ...(placement && { placement }) } : undefined;
+                }, ...(transport ? { transport } : {}), ...(latest.current.webSocket ? { webSocket: latest.current.webSocket } : {}) });
+            try {
+                controller = createNativeChatController({ identity: identity, ...remote });
+                remotes.set(controller, remote);
+                return controller;
+            }
+            catch (error) {
+                await remote.close();
+                throw error;
+            }
+        },
+        connect: controller => controller.connect(),
+        dispose: async (controller) => {
+            // Start both: closing a transport may release a pending native watch opening.
+            const pending = controller.dispose();
+            try {
+                await remotes.get(controller)?.close();
+            }
+            finally {
+                await pending;
+                remotes.delete(controller);
+            }
+        }, });
+    if (selected.status === 'ready' && conversationId !== undefined) {
+        const remote = remotes.get(selected.controller);
+        const actions = { ...(typeof remote.answer === 'function' ? { answer: remote.answer } : {}),
+            ...(typeof remote.withdraw === 'function' ? { withdraw: remote.withdraw } : {}) };
+        return { status: 'ready', conversationId, controller: selected.controller, actions, configure: remote.configure };
+    }
+    return selected.status === 'offline' ? { status: 'offline', conversationId, error: String(selected.error?.message ?? selected.error) } : { status: 'connecting', conversationId };
+}

package/dist/chat-react-session.d.ts

@@ -0,0 +1,170 @@
+import type { ToolCall, ToolResultMessage } from '@earendil-works/pi-ai';
+import type { ChatAttachment, ChatController } from './native-chat.js';
+import type { ChatCard, DeriveOptions, Mode, QueuedMessage, Row } from './chat-view.js';
+/** A conversation's observed file; opening remains a host operation, not workspace ownership. */
+export interface ConversationFile {
+    readonly id: string;
+    readonly name: string;
+    readonly open: (() => void) | undefined;
+}
+export interface ModelRef {
+    readonly provider: string;
+    readonly modelId: string;
+}
+export interface PastedText {
+    readonly text: string;
+    readonly start: number;
+    readonly end: number;
+}
+export interface UploadResult {
+    readonly path?: string;
+    readonly image?: {
+        readonly data: string;
+        readonly mimeType: string;
+    };
+    readonly name: string;
+}
+export interface PendingUpload {
+    readonly id: string;
+    readonly name: string;
+    readonly state: 'uploading' | 'failed';
+    readonly error?: string;
+    readonly cancel?: (() => void) | undefined;
+    readonly restoreWhile?: string | undefined;
+}
+export type FilesHandler = (files: readonly File[], target: Pick<ReturnType<ChatController['getSnapshot']>, 'identity' | 'conversationId'> & {
+    readonly signal: AbortSignal;
+}) => Promise<readonly ChatAttachment[]>;
+export interface QueueActions {
+    readonly edit?: ((item: QueuedMessage) => Promise<void>) | undefined;
+    readonly steer?: ((item: QueuedMessage) => Promise<void>) | undefined;
+}
+/** Send-time feedback only; the annotate button and its state remain host presentation. */
+export interface ChatSessionFeedback {
+    readonly count: number;
+    readonly attach: (text: string) => Promise<{
+        readonly kind: 'ok';
+        readonly text: string;
+    } | {
+        readonly kind: 'refused';
+        readonly reason: string;
+    }>;
+    readonly sent: () => void;
+}
+export interface ChatSessionLabels {
+    readonly connectionFailed: string;
+    readonly actionFailedShort: string;
+    readonly imageAttachment: string;
+    readonly queueLocked: string;
+    readonly tooLate: string;
+    readonly waitToSteer: string;
+    readonly steerRefused: string;
+    readonly steerFailed: string;
+    readonly uploadFailedShort: string;
+    readonly pastedFileName: (stamp: string) => string;
+    readonly changeRefused: string;
+}
+export interface ChatSessionOptions<Content = unknown> extends Partial<DeriveOptions<Content>> {
+    readonly controller: ChatController;
+    /** Surfaces remount on controller replacement. Late effects/actions also check this live binding. */
+    readonly activeController: {
+        readonly current: ChatController;
+    };
+    readonly mode: Mode;
+    readonly labels: ChatSessionLabels;
+    readonly actions?: {
+        readonly withdraw?: ((id: QueuedMessage['id']) => Promise<unknown>) | undefined;
+    } | undefined;
+    readonly toolRenderers?: Readonly<Record<string, (call: ToolCall, result: ToolResultMessage | undefined) => ChatCard<Content> | undefined>> | undefined;
+    readonly artifacts?: (NonNullable<DeriveOptions<Content>['artifacts']> & {
+        readonly open?: ((artifact: never) => void) | undefined;
+    }) | undefined;
+    readonly mentions?: {
+        readonly open?: ((path: string) => void) | undefined;
+        readonly kinds?: Readonly<Record<string, unknown>> | undefined;
+    } | undefined;
+    readonly slash?: {
+        readonly skills?: readonly {
+            readonly name: string;
+        }[] | undefined;
+    } | undefined;
+    readonly onOpenFile?: ((path: string) => void) | undefined;
+    readonly onOpenImage?: ((image: ChatAttachment['content']) => void) | undefined;
+    readonly onFiles?: FilesHandler | undefined;
+    readonly onPickFiles?: ((files: readonly File[]) => void) | undefined;
+    readonly attachments?: {
+        readonly upload: (files: File[], signal: AbortSignal) => Promise<readonly UploadResult[]>;
+    } | undefined;
+    readonly model?: {
+        readonly change: (model: ModelRef) => Promise<void>;
+    } | undefined;
+    readonly effort?: {
+        readonly change: (level: string) => Promise<void>;
+    } | undefined;
+    readonly commandMentions?: {
+        readonly commands: readonly {
+            readonly name: string;
+            readonly behavior: 'execute' | 'insert';
+        }[];
+        readonly onActivate: (command: {
+            readonly name: string;
+            readonly behavior: 'execute' | 'insert';
+        }) => void;
+    } | undefined;
+    readonly feedback?: ChatSessionFeedback | undefined;
+    readonly afterSend?: (() => void) | undefined;
+    /** Focus is presentation; called only by actions, never during render. */
+    readonly onFocus?: (() => void) | undefined;
+}
+/** Headless session over the public native controller snapshot/commands. Borrows it; cleanup only aborts this hook's uploads. */
+export declare function useChatSession<Content = unknown>(options: ChatSessionOptions<Content>): {
+    state: import("./native-chat.js").ChatSnapshot;
+    derived: import("./chat-view.js").Derived<Content>;
+    rows: Row<Content>[];
+    queued: {
+        id: import("@earendil-works/pi-durable").SubmissionId;
+        mode: "steer" | "followUp";
+        content: import("@earendil-works/chord").JsonRepresentation<import("@earendil-works/pi-durable").UserInput>;
+        entry?: import("@earendil-works/chord").JsonRepresentation<import("@earendil-works/pi-durable").InputEntry>;
+    }[];
+    queueActions: QueueActions | undefined;
+    working: boolean;
+    waitingForAnswer: boolean;
+    connected: boolean;
+    sendBlocked: boolean;
+    error: string | null;
+    setError: import("react").Dispatch<import("react").SetStateAction<string | null>>;
+    report: (cause: unknown) => void;
+    act: (action: () => Promise<unknown>) => void;
+    current: () => boolean;
+    files: ConversationFile[];
+    empty: boolean;
+    loading: boolean;
+    developer: boolean;
+    natural: boolean;
+    send: () => void;
+    putBack: (text: string, images: readonly ChatAttachment[]) => void;
+    upload: (files: readonly File[], paste?: {
+        readonly restore: () => void;
+        readonly after: string;
+    }) => Promise<void>;
+    pasteText: (paste: PastedText) => void;
+    picked: readonly string[];
+    pending: readonly PendingUpload[];
+    uploading: number;
+    activateMention: (command: {
+        readonly name: string;
+        readonly behavior: "execute" | "insert";
+    }) => void;
+    pickMention: (path: string) => void;
+    dismissUpload: (id: string) => void;
+    currentModel: ModelRef | undefined;
+    currentEffort: string | undefined;
+    changing: "model" | "effort" | null;
+    changeError: string | null;
+    dismissChangeError: () => void;
+    changeModel: (next: ModelRef) => Promise<void>;
+    changeEffort: (next: string) => Promise<void>;
+};
+export type ChatSession<Content = unknown> = ReturnType<typeof useChatSession<Content>>;
+//# sourceMappingURL=chat-react-session.d.ts.map