@ruimte/agents-react 0.0.0 → 0.7.0

package/dist/chat/actions.js

@@ -0,0 +1,64 @@
+import i18next from 'i18next';
+import { chatHost } from '../host';
+import { useChatScope } from '../scope';
+import { ChatTransportError } from '../transport';
+/* Every action as the request a chat host answers, for an app that runs them through nothing of its own. */
+export const transportActions = (transport) => ({
+    clear: async (chatId, force) => {
+        await transport.request('chat.clear', { chatId, ...(force ? { force: true } : {}) });
+    },
+    stopTurn: async (chatId, subagents) => {
+        await transport.request('chat.cancel', { chatId, ...(subagents ? { subagents: true } : {}) });
+    },
+    unqueue: async (chatId, messageId) => {
+        const { message } = await transport.request('chat.unqueue', { chatId, messageId });
+        // A host answers without the message once it went out, which is what the composer tells a person.
+        if (message === undefined) {
+            throw new ChatTransportError('request-not-found', i18next.t('agent-chat:composer.queue.alreadySent'));
+        }
+    },
+    sendNow: async (chatId, messageId) => {
+        await transport.request('chat.sendNow', { chatId, messageId });
+    },
+    compact: async (chatId) => {
+        await transport.request('chat.compact', { chatId });
+    },
+    configure: async (chatId, patch) => {
+        await transport.request('chat.configure', { chatId, ...patch });
+    },
+    continueOn: async (chatId, account) => {
+        await transport.request('chat.continueOn', { chatId, account });
+    },
+    turnDiff: async (chatId, turnId) => (await transport.request('chat.turnDiff', { chatId, turnId })).diff,
+    stopSubagent: async (chatId, toolUseId) => {
+        await transport.request('chat.stopSubagent', { chatId, toolUseId });
+    },
+    stopTask: async (chatId, taskId) => {
+        await transport.request('chat.stopTask', { chatId, taskId });
+    },
+    approve: async (chatId, requestId, decision, message) => {
+        await transport.request('chat.approve', { chatId, requestId, decision, ...(message === undefined ? {} : { message }) });
+    },
+    answer: async (chatId, requestId, answers) => {
+        await transport.request('chat.answer', { chatId, requestId, answers });
+    },
+    dismiss: async (chatId, itemId) => {
+        await transport.request('chat.dismiss', { chatId, itemId });
+    }
+});
+const byTransport = new WeakMap();
+/* The app's own actions when it has them, and the requests of this scope's host otherwise. */
+export const actionsOf = (scope) => {
+    const own = chatHost().actions;
+    if (own !== null) {
+        return own;
+    }
+    const { transport } = scope;
+    let actions = byTransport.get(transport);
+    if (actions === undefined) {
+        actions = transportActions(transport);
+        byTransport.set(transport, actions);
+    }
+    return actions;
+};
+export const useChatActions = () => actionsOf(useChatScope());

package/dist/chat/activity.d.ts

@@ -0,0 +1,5 @@
+import type { ChatBackgroundTask } from '@ruimte/agent-contracts';
+export declare const backgroundCounts: (tasks: readonly ChatBackgroundTask[]) => {
+    shells: number;
+    monitors: number;
+};

package/dist/chat/activity.js

@@ -0,0 +1,4 @@
+export const backgroundCounts = (tasks) => ({
+    shells: tasks.filter((task) => task.kind === 'shell').length,
+    monitors: tasks.filter((task) => task.kind === 'monitor').length
+});

package/dist/chat/attachments.d.ts

@@ -0,0 +1,23 @@
+import { type ChatAttachment, type ChatAttachmentUpload } from '@ruimte/agent-contracts';
+interface IncomingFile {
+    name: string;
+    mime: string;
+    bytes: number;
+}
+interface AttachmentCheck<T extends IncomingFile> {
+    accepted: T[];
+    rejected: Array<{
+        name: string;
+        reason: string;
+    }>;
+}
+export declare const isImageAttachment: (mime: string) => boolean;
+export declare const fileBadge: (name: string) => string | null;
+export declare const formatBytes: (bytes: number) => string;
+export declare const checkAttachmentLimits: <T extends IncomingFile>(current: number, incoming: T[], currentBytes?: number) => AttachmentCheck<T>;
+export declare const filesOf: (transfer: DataTransfer | null) => File[];
+export declare const readAttachments: (files: File[]) => Promise<ChatAttachmentUpload[]>;
+export declare const readStoredAttachments: (read: (attachment: ChatAttachment) => Promise<Blob>, stored: readonly ChatAttachment[]) => Promise<ChatAttachmentUpload[]>;
+export declare const uploadPreviewUrl: (upload: ChatAttachmentUpload) => string;
+export declare const uploadBytes: (upload: ChatAttachmentUpload) => number;
+export {};

package/dist/chat/attachments.js

@@ -0,0 +1,70 @@
+import i18next from 'i18next';
+import { attachmentBytes, attachmentImageMime, CHAT_ATTACHMENTS_MAX_BYTES, CHAT_ATTACHMENTS_MAX_COUNT, CHAT_ATTACHMENT_MAX_BYTES } from '@ruimte/agent-contracts';
+import { formatBytes as bytesOf } from '@ruimte/ui/format/number';
+export const isImageAttachment = (mime) => mime.startsWith('image/');
+/* The type on a file card: the extension, as long as it is short enough to read as one. */
+export const fileBadge = (name) => {
+    const dot = name.lastIndexOf('.');
+    if (dot <= 0 || dot === name.length - 1) {
+        return null;
+    }
+    const extension = name.slice(dot + 1);
+    return extension.length <= 5 ? extension.toUpperCase() : null;
+};
+/* Whole kilobytes, which is all a row under a file name has room for, and a decimal once it runs into megabytes. */
+export const formatBytes = (bytes) => bytesOf(bytes, bytes < 1024 * 1024);
+/* Which of the incoming files fit next to what the composer already holds, and why the rest do not. */
+export const checkAttachmentLimits = (current, incoming, currentBytes = 0) => {
+    const accepted = [];
+    const rejected = [];
+    let bytes = currentBytes;
+    for (const file of incoming) {
+        if (file.bytes === 0) {
+            rejected.push({ name: file.name, reason: i18next.t('agent-chat:attachments.rejected.empty') });
+        }
+        else if (file.bytes > CHAT_ATTACHMENT_MAX_BYTES) {
+            rejected.push({ name: file.name, reason: i18next.t('agent-chat:attachments.rejected.tooLarge', { size: formatBytes(CHAT_ATTACHMENT_MAX_BYTES) }) });
+        }
+        else if (current + accepted.length >= CHAT_ATTACHMENTS_MAX_COUNT) {
+            rejected.push({ name: file.name, reason: i18next.t('agent-chat:attachments.rejected.tooMany', { count: CHAT_ATTACHMENTS_MAX_COUNT }) });
+        }
+        else if (bytes + file.bytes > CHAT_ATTACHMENTS_MAX_BYTES) {
+            rejected.push({
+                name: file.name,
+                reason: i18next.t('agent-chat:attachments.rejected.tooHeavy', { size: formatBytes(CHAT_ATTACHMENTS_MAX_BYTES) })
+            });
+        }
+        else {
+            accepted.push(file);
+            bytes += file.bytes;
+        }
+    }
+    return { accepted, rejected };
+};
+/* The files in a paste or a drop; a paste of plain text gives none. */
+export const filesOf = (transfer) => (transfer ? [...transfer.files] : []);
+const readAsBase64 = (file) => new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onerror = () => reject(reader.error ?? new Error(i18next.t('agent-chat:attachments.unreadable', { name: file.name })));
+    reader.onload = () => {
+        const url = String(reader.result);
+        resolve(url.slice(url.indexOf(',') + 1));
+    };
+    reader.readAsDataURL(file);
+});
+// A pasted screenshot has no name; the clock gives it one so the row and the agent can tell them apart.
+const nameFor = (file, index) => file.name || `pasted-${Date.now()}-${index + 1}.${file.type.split('/')[1] ?? 'bin'}`;
+export const readAttachments = async (files) => Promise.all(files.map(async (file, index) => ({
+    name: nameFor(file, index),
+    mime: attachmentImageMime({ name: file.name, mime: file.type }) ?? (file.type || 'application/octet-stream'),
+    data: await readAsBase64(file)
+})));
+/* Files the host already stored for a chat, back as uploads the composer can hold again. */
+export const readStoredAttachments = async (read, stored) => {
+    const files = await Promise.all(stored.map(async (attachment) => new File([await read(attachment)], attachment.name, { type: attachment.mime })));
+    return readAttachments(files);
+};
+/* A preview of a file the composer still holds; the bytes have not reached the host yet. */
+export const uploadPreviewUrl = (upload) => `data:${upload.mime};base64,${upload.data}`;
+/* What the file weighs, from the base64 the composer is holding: three bytes per four characters. */
+export const uploadBytes = (upload) => attachmentBytes(upload.data);

package/dist/chat/bookmarks.d.ts

@@ -0,0 +1,14 @@
+import type { ChatBookmark } from '@ruimte/agent-contracts';
+import type { ChatScope } from '../scope';
+interface BookmarkNaming {
+    chatKey: string | null;
+    itemId: string | null;
+    open(chatKey: string, itemId: string): void;
+    close(): void;
+}
+export declare const useBookmarkNaming: import("zustand").UseBoundStore<import("zustand").StoreApi<BookmarkNaming>>;
+export declare const placeBookmark: (scope: ChatScope, chatId: string, itemId: string) => Promise<void>;
+export declare const nameBookmark: (scope: ChatScope, chatId: string, itemId: string, name: string, previous: string | undefined) => Promise<void>;
+export declare const removeBookmark: (scope: ChatScope, chatId: string, bookmark: ChatBookmark) => Promise<void>;
+export declare const goToBookmark: (scope: ChatScope, chatId: string, itemId: string, rename?: boolean) => boolean;
+export {};

package/dist/chat/bookmarks.js

@@ -0,0 +1,73 @@
+import i18next from 'i18next';
+import { create } from 'zustand';
+import { chatHost } from '../host';
+import { jumpToTimelineItem } from './timeline-scroll';
+export const useBookmarkNaming = create((set) => ({
+    chatKey: null,
+    itemId: null,
+    open: (chatKey, itemId) => set({ chatKey, itemId }),
+    close: () => set({ chatKey: null, itemId: null })
+}));
+const failed = (title, e) => {
+    chatHost().notify({ title, description: e instanceof Error ? e.message : String(e), kind: 'error' });
+};
+const add = async (scope, chatId, itemId, name) => {
+    try {
+        await scope.chats.addBookmark(chatId, itemId, name);
+        return true;
+    }
+    catch (e) {
+        failed(i18next.t('agent-chat:bookmarks.addFailed'), e);
+        return false;
+    }
+};
+/* Marks a message and opens the field for its name at once, before the host answered. */
+export const placeBookmark = async (scope, chatId, itemId) => {
+    useBookmarkNaming.getState().open(scope.keyOf(chatId), itemId);
+    if (!(await add(scope, chatId, itemId))) {
+        useBookmarkNaming.getState().close();
+    }
+};
+/*
+ * The name a field settles on. A name goes through `addBookmark`, which also names a bookmark that
+ * already stands, so a name typed before the mark itself landed is not refused.
+ */
+export const nameBookmark = async (scope, chatId, itemId, name, previous) => {
+    const next = name.trim();
+    if (next === (previous ?? '')) {
+        return;
+    }
+    if (next !== '') {
+        await add(scope, chatId, itemId, next);
+        return;
+    }
+    try {
+        await scope.chats.renameBookmark(chatId, itemId, '');
+    }
+    catch (e) {
+        failed(i18next.t('agent-chat:bookmarks.renameFailed'), e);
+    }
+};
+/* Takes a bookmark away at once; the toast puts it back, name and all. */
+export const removeBookmark = async (scope, chatId, bookmark) => {
+    try {
+        await scope.chats.removeBookmark(chatId, bookmark.itemId);
+    }
+    catch (e) {
+        failed(i18next.t('agent-chat:bookmarks.removeFailed'), e);
+        return;
+    }
+    chatHost().notify({
+        title: i18next.t('agent-chat:bookmarks.removed'),
+        kind: 'deleted',
+        action: { label: i18next.t('agent-chat:common.action.undo'), run: () => void add(scope, chatId, bookmark.itemId, bookmark.name) }
+    });
+};
+/* Scrolls the chat's thread to the message, and opens its name field for a rename. False when no thread of it is on screen yet. */
+export const goToBookmark = (scope, chatId, itemId, rename = false) => {
+    const key = scope.keyOf(chatId);
+    if (rename) {
+        useBookmarkNaming.getState().open(key, itemId);
+    }
+    return jumpToTimelineItem(key, itemId);
+};

package/dist/chat/chat-client.d.ts

@@ -0,0 +1,53 @@
+import type { AgentKind, ChatAttachmentUpload, ChatAttachResult, ChatBookmark, ChatPreferencesPayload, ChatSkill, ModelSelection, ProviderInfo, RuntimeMode } from '@ruimte/agent-contracts';
+import type { ChatSink } from '../state/chats';
+import { type ChatTransport } from '../transport';
+interface ChatOpenOptions {
+    provider?: AgentKind;
+    account?: string;
+    cwd?: string;
+    resume?: string;
+    selection?: ModelSelection;
+    runtimeMode?: RuntimeMode;
+}
+export interface ChatSendExtras {
+    mentions?: string[];
+    skills?: string[];
+    chats?: string[];
+    attachments?: ChatAttachmentUpload[];
+}
+interface ProviderSink {
+    setProviders(providers: ProviderInfo[]): void;
+}
+export declare class ChatClient {
+    private readonly transport;
+    private readonly sink;
+    private readonly providers;
+    private readonly mounted;
+    private readonly unsubscribe;
+    private preferences;
+    constructor(transport: ChatTransport, sink: ChatSink, providers?: ProviderSink | null);
+    private readonly inspections;
+    inspect(chatId: string): Promise<ChatAttachResult>;
+    open(chatId: string, options: ChatOpenOptions): Promise<boolean>;
+    retarget(chatId: string, provider: AgentKind, selection: ModelSelection): Promise<void>;
+    setPreferences(preferences: ChatPreferencesPayload): void;
+    detach(chatId: string): Promise<void>;
+    send(chatId: string, text: string, extras?: ChatSendExtras): Promise<{
+        queued: boolean;
+        turnId?: string;
+    }>;
+    addBookmark(chatId: string, itemId: string, name?: string): Promise<ChatBookmark[]>;
+    renameBookmark(chatId: string, itemId: string, name: string): Promise<ChatBookmark[]>;
+    removeBookmark(chatId: string, itemId: string): Promise<ChatBookmark[]>;
+    listSkills(chatId: string): Promise<ChatSkill[]>;
+    clear(chatId: string, force?: boolean): Promise<void>;
+    kill(chatId: string): Promise<void>;
+    loadStatuses(): Promise<void>;
+    loadProviders(): Promise<void>;
+    isMounted(chatId: string): boolean;
+    dispose(): void;
+    private attach;
+    private sendPreferences;
+    private onStatus;
+}
+export {};

package/dist/chat/chat-client.js

@@ -0,0 +1,232 @@
+import { MountedRegistry } from '../mounted-registry';
+import { isConnectionError } from '../transport';
+/*
+ * One chat per chat id on one host. A chat opens on mount and detaches on unmount, and every mounted
+ * chat is attached again when the transport comes back. The provider list is fetched once per
+ * connection and handed to its own store. The transport it is given never changes hosts, so a
+ * reattach stays on the host these chats run on.
+ */
+export class ChatClient {
+    transport;
+    sink;
+    providers;
+    mounted = new MountedRegistry();
+    unsubscribe = [];
+    preferences = null;
+    constructor(transport, sink, providers = null) {
+        this.transport = transport;
+        this.sink = sink;
+        this.providers = providers;
+        this.unsubscribe.push(transport.on('chat.event', ({ chatId, event, seq }) => {
+            this.sink.apply(chatId, event);
+            const entry = this.mounted.get(chatId);
+            if (entry && seq !== undefined) {
+                entry.seq = seq;
+            }
+        }), 
+        // Every chat on the machine, attached or not, so a node waiting on a person says so on a view nobody has open.
+        transport.on('chat.status', ({ chatId, info }) => this.sink.status(chatId, info)), transport.on('chat.bookmarks', ({ chatId, bookmarks }) => this.sink.bookmarks(chatId, bookmarks)), transport.subscribeStatus((status) => this.onStatus(status)));
+        if (transport.status === 'open') {
+            void this.loadProviders();
+            void this.loadStatuses();
+        }
+    }
+    inspections = new Map();
+    inspect(chatId) {
+        const pending = this.inspections.get(chatId);
+        if (pending) {
+            return pending;
+        }
+        const read = this.transport.request('chat.attach', { chatId, historyLimit: 100 }).finally(async () => {
+            this.inspections.delete(chatId);
+            // A visible chat owns its attachment; an inspection must never release it.
+            if (!this.mounted.get(chatId)) {
+                await this.transport.request('chat.detach', { chatId }).catch(() => undefined);
+            }
+        });
+        this.inspections.set(chatId, read);
+        return read;
+    }
+    /* Answers false when the transport is not connected; the chat opens once it is. */
+    async open(chatId, options) {
+        this.mounted.set(chatId, { ...options, attached: false });
+        try {
+            await this.attach(chatId);
+            return true;
+        }
+        catch (e) {
+            if (isConnectionError(e)) {
+                return false;
+            }
+            throw e;
+        }
+    }
+    /*
+     * Points a chat that has not spoken yet at another CLI. The host fixes a chat's provider when
+     * it registers the chat, so the only way over is to drop the empty one and register it again.
+     */
+    async retarget(chatId, provider, selection) {
+        const entry = this.mounted.get(chatId);
+        if (!entry) {
+            return;
+        }
+        // The account belonged to the CLI the chat leaves.
+        const { attached: _attached, account: _account, ...options } = entry;
+        this.mounted.delete(chatId);
+        await this.transport.request('chat.kill', { chatId });
+        this.sink.forget(chatId);
+        await this.open(chatId, { ...options, provider, selection });
+    }
+    /*
+     * Tells the host what a chat it starts on its own is made with while this socket is connected,
+     * since no client mounting that chat sends a composer preference. Said again on every fresh socket.
+     */
+    setPreferences(preferences) {
+        this.preferences = preferences;
+        this.sendPreferences();
+    }
+    async detach(chatId) {
+        const entry = this.mounted.get(chatId);
+        this.mounted.delete(chatId);
+        if (!entry?.attached) {
+            return;
+        }
+        try {
+            await this.transport.request('chat.detach', { chatId });
+        }
+        catch {
+            // The socket closing detaches every chat server-side anyway.
+        }
+    }
+    /* Current hosts return the stable turn id; older compatible ones only report whether the message queued. */
+    async send(chatId, text, extras = {}) {
+        return this.transport.request('chat.send', {
+            chatId,
+            text,
+            mentions: extras.mentions,
+            skills: extras.skills,
+            chats: extras.chats,
+            attachments: extras.attachments
+        });
+    }
+    /* Marks a message; the list every client of the chat holds comes back as `chat.bookmarks`. */
+    async addBookmark(chatId, itemId, name) {
+        const { bookmarks } = await this.transport.request('chat.addBookmark', { chatId, itemId, ...(name === undefined ? {} : { name }) });
+        return bookmarks;
+    }
+    /* An empty name takes the name away. */
+    async renameBookmark(chatId, itemId, name) {
+        const { bookmarks } = await this.transport.request('chat.renameBookmark', { chatId, itemId, name });
+        return bookmarks;
+    }
+    async removeBookmark(chatId, itemId) {
+        const { bookmarks } = await this.transport.request('chat.removeBookmark', { chatId, itemId });
+        return bookmarks;
+    }
+    /* What this chat's CLI would run as a skill, for the composer's `$` picker. */
+    async listSkills(chatId) {
+        const { skills } = await this.transport.request('skills.list', { chatId });
+        return skills;
+    }
+    /* Starts the chat over; refused with `chat-busy` while a turn runs, unless `force` stops that turn. */
+    async clear(chatId, force = false) {
+        await this.transport.request('chat.clear', { chatId, ...(force ? { force: true } : {}) });
+    }
+    async kill(chatId) {
+        this.mounted.delete(chatId);
+        this.sink.forget(chatId);
+        await this.transport.request('chat.kill', { chatId });
+    }
+    /*
+     * What every chat on this machine is doing right now. `chat.status` only carries a change, so a
+     * window that just opened or came back from a lost socket asks for the standing answer.
+     */
+    async loadStatuses() {
+        try {
+            const { chats } = await this.transport.request('chat.list', {});
+            for (const info of chats) {
+                this.sink.status(info.chatId, info);
+            }
+        }
+        catch {
+            // The next status event says it instead; an older host never answers this at all.
+        }
+    }
+    async loadProviders() {
+        if (!this.providers) {
+            return;
+        }
+        try {
+            const { providers } = await this.transport.request('provider.list', {});
+            this.providers.setProviders(providers);
+        }
+        catch {
+            // The list comes with the next connection; pickers show what they had.
+        }
+    }
+    isMounted(chatId) {
+        return this.mounted.has(chatId);
+    }
+    /* Lets go of the machine; the chats keep running there, the host only stops streaming them here. */
+    dispose() {
+        for (const off of this.unsubscribe) {
+            off();
+        }
+        this.unsubscribe.length = 0;
+        for (const chatId of [...this.mounted.keys()]) {
+            void this.detach(chatId);
+        }
+    }
+    /*
+     * A reattach offers the last seq the store holds. The host answers only what came after it when
+     * it still has all of that, and the whole thread otherwise, so a short drop costs a few events.
+     */
+    async attach(chatId) {
+        const entry = this.mounted.get(chatId);
+        await this.transport.request('chat.create', {
+            chatId,
+            provider: entry?.provider,
+            account: entry?.account,
+            cwd: entry?.cwd,
+            resume: entry?.resume,
+            selection: entry?.selection,
+            runtimeMode: entry?.runtimeMode
+        });
+        const since = entry?.seq;
+        const result = await this.transport.request('chat.attach', { chatId, ...(since === undefined ? {} : { since }) });
+        const current = this.mounted.get(chatId);
+        if (!current) {
+            return;
+        }
+        current.attached = true;
+        if (result.seq !== undefined) {
+            current.seq = result.seq;
+        }
+        if (result.events && since !== undefined && current === entry) {
+            for (const event of result.events) {
+                this.sink.apply(chatId, event);
+            }
+        }
+        else {
+            this.sink.reset(chatId, result.info, result.items);
+        }
+        // A host without bookmarks sends none, and then this chat has none.
+        this.sink.bookmarks(chatId, result.bookmarks ?? []);
+    }
+    sendPreferences() {
+        if (this.preferences === null) {
+            return;
+        }
+        void this.transport.request('chat.setPreferences', this.preferences).catch(() => undefined);
+    }
+    onStatus(status) {
+        if (status === 'open') {
+            this.sendPreferences();
+            void this.loadProviders();
+            void this.loadStatuses();
+            void this.mounted.reattachAll((chatId) => this.attach(chatId).then(() => undefined));
+            return;
+        }
+        this.mounted.detachAll();
+    }
+}

package/dist/chat/chat-references.d.ts

@@ -0,0 +1,5 @@
+export interface ProjectChat {
+    id: string;
+    title: string;
+}
+export declare const chatSuggestions: (chats: readonly ProjectChat[], query: string, exclude: readonly string[], limit: number) => ProjectChat[];

package/dist/chat/chat-references.js

@@ -0,0 +1,5 @@
+/* The chats an `@query` offers: never the chat typing it or one already attached. */
+export const chatSuggestions = (chats, query, exclude, limit) => {
+    const needle = query.toLowerCase();
+    return chats.filter((chat) => !exclude.includes(chat.id) && chat.title.toLowerCase().includes(needle)).slice(0, limit);
+};

package/dist/chat/drafts.d.ts

@@ -0,0 +1,29 @@
+import type { ChatAttachmentUpload } from '@ruimte/agent-contracts';
+export interface ChatDraft {
+    text: string;
+    mentions: string[];
+    skills: string[];
+    chats: string[];
+    attachments: ChatAttachmentUpload[];
+    quote: string;
+}
+export declare const EMPTY_DRAFT: ChatDraft;
+export declare const isEmptyDraft: (draft: ChatDraft) => boolean;
+export declare const useDrafts: import("zustand").UseBoundStore<import("zustand").StoreApi<{
+    ids: string[];
+}>>;
+export declare const useHasDraft: (chatId: string) => boolean;
+export declare const readDraft: (chatId: string) => ChatDraft;
+export declare const writeDraft: (chatId: string, draft: ChatDraft) => void;
+export declare const joinDraftText: (current: string, added: string) => string;
+export declare const takeBackIntoDraft: (current: ChatDraft, taken: Omit<ChatDraft, 'quote'>) => {
+    draft: ChatDraft;
+    rejected: Array<{
+        name: string;
+        reason: string;
+    }>;
+};
+type DraftTaker = (text: string) => void;
+export declare const takeDraftOffers: (chatId: string, take: DraftTaker) => (() => void);
+export declare const offerDraft: (chatId: string, text: string) => void;
+export {};