@theoremjs/react 0.0.0-stage → 0.3.0

package/components/use-composer-voice.js

@@ -0,0 +1,90 @@
+import { useCallback, useRef, useState } from 'react';
+import { attachmentIssueText, describeError, lexiconText, } from '@theoremjs/agents';
+import { canStageVoice } from "../client/composer-attachments.js";
+import { ComposerVoiceRecorder, isVoiceRecorderFailure, } from "../client/voice-recorder.js";
+function voiceFailure(err, fallback, lexicon) {
+    const code = isVoiceRecorderFailure(err) ? err.code : fallback;
+    const internal = describeError(err);
+    return {
+        code,
+        error: lexiconText(`voice.${code}`, {}, lexicon),
+        ...(internal && internal !== code ? { errorInternal: internal } : {}),
+    };
+}
+export function useComposerVoice(args) {
+    const [recording, setRecording] = useState(false);
+    const [inputLevel, setInputLevel] = useState(0);
+    const [failure, setFailure] = useState(null);
+    const recorderRef = useRef(null);
+    const onVoiceStagedRef = useRef(args.onVoiceStaged);
+    const onVoiceClearRef = useRef(args.onVoiceClear);
+    onVoiceStagedRef.current = args.onVoiceStaged;
+    onVoiceClearRef.current = args.onVoiceClear;
+    const ensureRecorder = useCallback(() => {
+        recorderRef.current ??= new ComposerVoiceRecorder(args.inputs.voice?.accept ?? [], (level) => {
+            setInputLevel(level);
+        });
+        return recorderRef.current;
+    }, [args.inputs.voice?.accept]);
+    const startRecording = useCallback(async () => {
+        setFailure(null);
+        const maxFiles = args.inputs.maxFiles;
+        if (!canStageVoice({ fileCount: args.pendingFiles.length, maxFiles })) {
+            setFailure({
+                code: 'too_many_files',
+                error: attachmentIssueText({ code: 'too_many_files', params: { maxFiles } }, args.lexicon),
+            });
+            return;
+        }
+        onVoiceClearRef.current?.();
+        try {
+            await ensureRecorder().start();
+            setRecording(true);
+        }
+        catch (err) {
+            setRecording(false);
+            setFailure(voiceFailure(err, 'unavailable', args.lexicon));
+        }
+    }, [args.inputs.maxFiles, args.lexicon, args.pendingFiles.length, ensureRecorder]);
+    const stopRecording = useCallback(async () => {
+        setFailure(null);
+        try {
+            const file = await ensureRecorder().stop();
+            setRecording(false);
+            setInputLevel(0);
+            onVoiceStagedRef.current?.(file);
+        }
+        catch (err) {
+            setRecording(false);
+            setInputLevel(0);
+            setFailure(voiceFailure(err, 'failed', args.lexicon));
+        }
+    }, [args.lexicon, ensureRecorder]);
+    const toggleRecording = useCallback(async () => {
+        if (recording) {
+            await stopRecording();
+            return;
+        }
+        await startRecording();
+    }, [recording, startRecording, stopRecording]);
+    const discardRecordingOrVoice = useCallback(() => {
+        if (recording) {
+            ensureRecorder().cancel();
+            setRecording(false);
+            setInputLevel(0);
+        }
+        onVoiceClearRef.current?.();
+    }, [ensureRecorder, recording]);
+    const disposeRecorder = useCallback(() => {
+        recorderRef.current?.dispose();
+    }, []);
+    return {
+        recording,
+        inputLevel,
+        failure,
+        setFailure,
+        toggleRecording,
+        discardRecordingOrVoice,
+        disposeRecorder,
+    };
+}

package/components/use-editor-selection.d.ts

@@ -0,0 +1,3 @@
+import { type RefObject } from 'react';
+/** Text currently selected inside `ref` (a contenteditable), or '' when the selection is elsewhere. */
+export declare function useEditorSelection(ref: RefObject<HTMLElement | null>): string;

package/components/use-editor-selection.js

@@ -0,0 +1,16 @@
+import { useEffect, useState } from 'react';
+/** Text currently selected inside `ref` (a contenteditable), or '' when the selection is elsewhere. */
+export function useEditorSelection(ref) {
+    const [selected, setSelected] = useState('');
+    useEffect(() => {
+        const read = () => {
+            const root = ref.current;
+            const selection = document.getSelection();
+            const inside = root && selection && selection.rangeCount > 0 && root.contains(selection.getRangeAt(0).commonAncestorContainer);
+            setSelected(inside ? selection.toString() : '');
+        };
+        document.addEventListener('selectionchange', read);
+        return () => document.removeEventListener('selectionchange', read);
+    }, [ref]);
+    return selected;
+}

package/components/use-voice-playback.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Click-to-play state for a voice note: an `<audio>` ref, whether it plays,
+ * and a gentle output level that drives the ink waveform while it does.
+ */
+export declare function useVoicePlayback(): {
+    playing: boolean;
+    outputLevel: number;
+    toggle: () => Promise<void>;
+    audioProps: {
+        ref: import("react").RefObject<HTMLAudioElement | null>;
+        preload: "metadata";
+        onPlay: () => void;
+        onPause: () => void;
+        onEnded: () => void;
+    };
+};

package/components/use-voice-playback.js

@@ -0,0 +1,68 @@
+import { useEffect, useRef, useState } from 'react';
+/**
+ * Click-to-play state for a voice note: an `<audio>` ref, whether it plays,
+ * and a gentle output level that drives the ink waveform while it does.
+ */
+export function useVoicePlayback() {
+    const audioRef = useRef(null);
+    const [playing, setPlaying] = useState(false);
+    const playingRef = useRef(false);
+    const [outputLevel, setOutputLevel] = useState(0);
+    const rafIdRef = useRef(0);
+    function stopMeter() {
+        cancelAnimationFrame(rafIdRef.current);
+        rafIdRef.current = 0;
+        setOutputLevel(0);
+    }
+    function startMeter() {
+        stopMeter();
+        const tick = (time) => {
+            if (!playingRef.current)
+                return;
+            setOutputLevel(0.28 + 0.22 * (0.5 + 0.5 * Math.sin(time * 0.008)));
+            rafIdRef.current = requestAnimationFrame(tick);
+        };
+        rafIdRef.current = requestAnimationFrame(tick);
+    }
+    useEffect(() => {
+        return () => {
+            cancelAnimationFrame(rafIdRef.current);
+        };
+    }, []);
+    function settle(isPlaying) {
+        playingRef.current = isPlaying;
+        setPlaying(isPlaying);
+        if (isPlaying)
+            startMeter();
+        else
+            stopMeter();
+    }
+    async function toggle() {
+        const audio = audioRef.current;
+        if (!audio)
+            return;
+        if (!audio.paused) {
+            audio.pause();
+            return;
+        }
+        try {
+            await audio.play();
+        }
+        catch {
+            settle(false);
+        }
+    }
+    /** Spread onto the `<audio>` element. */
+    const audioProps = {
+        ref: audioRef,
+        preload: 'metadata',
+        onPlay: () => settle(true),
+        onPause: () => settle(false),
+        onEnded: () => {
+            settle(false);
+            if (audioRef.current)
+                audioRef.current.currentTime = 0;
+        },
+    };
+    return { playing, outputLevel, toggle, audioProps };
+}

package/hooks/use-described.d.ts

@@ -0,0 +1,8 @@
+import { type ClientFailure } from '../client/failure.ts';
+/** What a transport describes, read once per transport; a failure when it can't be read. */
+export declare function useDescribed<T>(transport: {
+    describe: (signal?: AbortSignal) => Promise<T>;
+}): {
+    iface: T | null;
+    describeFailure: ClientFailure | null;
+};

package/hooks/use-described.js

@@ -0,0 +1,23 @@
+import { useEffect, useState } from 'react';
+import { clientFailure } from "../client/failure.js";
+/** What a transport describes, read once per transport; a failure when it can't be read. */
+export function useDescribed(transport) {
+    const [description, setDescription] = useState(null);
+    useEffect(() => {
+        const controller = new AbortController();
+        transport.describe(controller.signal).then((described) => {
+            if (controller.signal.aborted)
+                return;
+            setDescription({ transport, iface: described, describeFailure: null });
+        }, (err) => {
+            if (!controller.signal.aborted)
+                setDescription({ transport, iface: null, describeFailure: clientFailure(err) });
+        });
+        return () => {
+            controller.abort();
+        };
+    }, [transport]);
+    return description?.transport === transport
+        ? { iface: description.iface, describeFailure: description.describeFailure }
+        : { iface: null, describeFailure: null };
+}

package/hooks/use-theorem-chat-actions.d.ts

@@ -0,0 +1,75 @@
+import { type MutableRefObject } from 'react';
+import type { AttachmentValidationIssue, ComposerMenuAction, ComposerPendingMessage, ComposerProfileInterface, ComposerRunPhase, InterfaceTurnSession, TranscriptBlock } from '@theoremjs/agents/interface';
+import { type AnsweringGate, type StreamView, type ToolDecisionAction } from '../client/index.ts';
+import { type ClientFailure, type TurnFailure } from '../client/failure.ts';
+import type { TheoremTransport } from '../client/transport.ts';
+import type { MessageDelivery } from './use-theorem-chat-state.ts';
+export type RunTurnStream = (run: (view: StreamView, 
+/** The work so far of the reply the session waits on (none when it waits on nothing). */
+paused: {
+    workedMs: number;
+}) => Promise<{
+    ok: true;
+    session: InterfaceTurnSession;
+    userBlocks?: TranscriptBlock[];
+    assistantBlocks: TranscriptBlock[];
+} | TurnFailure>, options?: {
+    userBlocksAlreadyApplied?: boolean;
+    /** The run's message walks away from the gates the reply waits on, ending that reply. */
+    walksAway?: boolean;
+}) => Promise<void>;
+export type TheoremChatActionArgs = {
+    iface: ComposerProfileInterface | null;
+    transport: TheoremTransport;
+    phase: ComposerRunPhase;
+    gated: boolean;
+    draftText: string;
+    pendingFiles: File[];
+    pendingVoice: File[];
+    clearComposer: () => void;
+    runTurnStream: RunTurnStream;
+    sessionRef: MutableRefObject<InterfaceTurnSession>;
+    blocksRef: MutableRefObject<TranscriptBlock[]>;
+    abortRef: MutableRefObject<AbortController | null>;
+    turnIdRef: MutableRefObject<string | null>;
+    busyRef: MutableRefObject<boolean>;
+    runPromiseRef: MutableRefObject<Promise<void> | null>;
+    allowQueueDrainRef: MutableRefObject<boolean>;
+    setBlocks: (value: TranscriptBlock[] | ((prev: TranscriptBlock[]) => TranscriptBlock[])) => void;
+    setStreamBlocks: (value: TranscriptBlock[]) => void;
+    setSession: (value: InterfaceTurnSession) => void;
+    setChatStarted: (value: boolean) => void;
+    setStreaming: (value: boolean) => void;
+    setPendingMessages: (value: ComposerPendingMessage[] | ((prev: ComposerPendingMessage[]) => ComposerPendingMessage[])) => void;
+    setDraftText: (value: string) => void;
+    setPendingFiles: (value: File[]) => void;
+    setPendingVoice: (value: File[]) => void;
+    setIssues: (value: AttachmentValidationIssue[]) => void;
+    setFailure: (value: ClientFailure | null) => void;
+    setAnswering: (value: AnsweringGate | null) => void;
+    setDelivery: (value: {
+        status: MessageDelivery;
+    } | null) => void;
+    pendingRef: MutableRefObject<ComposerPendingMessage[]>;
+};
+export declare function useTheoremChatActions(args: TheoremChatActionArgs): {
+    startTurnFromFields: (fields: {
+        text: string;
+        files: File[];
+        voice: File[];
+    }) => Promise<void>;
+    startTurnFromDraft: (draft: ComposerPendingMessage["draft"], options?: {
+        /** Send while the reply waits on gates: the message walks away from them. */
+        walkAway?: boolean;
+        /** Once the message posts: it leaves wherever it was waiting to be sent. */
+        onPosted?: () => void;
+    }) => Promise<void>;
+    handleStop: () => void;
+    handleSubmit: () => Promise<void>;
+    handleSendNow: (draftSource?: ComposerPendingMessage) => Promise<void>;
+    handleMenuAction: (action: ComposerMenuAction) => void;
+    handleToolDecision: (_index: number, action: ToolDecisionAction) => Promise<void>;
+    handleAuthenticated: (_index: number, secret?: string) => Promise<void>;
+    handlePendingRestore: (id: string) => Promise<void>;
+    enqueuePending: (kind: "queue" | "steer" | "stash") => Promise<void>;
+};

package/hooks/use-theorem-chat-actions.js

@@ -0,0 +1,265 @@
+import { useCallback } from 'react';
+import { TheoremError } from '@theoremjs/agents';
+import { convertSteersToFrontQueued, createComposerPendingMessage, orderComposerPendingMessages, removeComposerPendingMessage, userDraftHasPayload, userDraftToSteerInject, } from '@theoremjs/agents/interface';
+import { composerFieldsFromDraft, encodeComposerDraft, resumeInterfaceTool, streamInterfaceDraftTurn, streamInterfaceTurn, } from "../client/index.js";
+import { clientFailure } from "../client/failure.js";
+function composerFieldsPayload(text, pendingFiles, pendingVoice) {
+    const meta = (files) => files.map((f) => ({
+        name: f.name,
+        mimeType: f.type || 'application/octet-stream',
+        sizeBytes: f.size,
+    }));
+    return {
+        ...(text.trim() ? { text } : {}),
+        ...(pendingFiles.length ? { attachments: meta(pendingFiles) } : {}),
+        ...(pendingVoice.length ? { voice: meta(pendingVoice) } : {}),
+    };
+}
+function newTurnId() {
+    return typeof crypto !== 'undefined' && 'randomUUID' in crypto
+        ? crypto.randomUUID()
+        : `turn-${Date.now()}`;
+}
+function beginAbortableTurn(args) {
+    if (!args.iface)
+        return null;
+    const controller = new AbortController();
+    args.abortRef.current = controller;
+    const turnId = newTurnId();
+    args.turnIdRef.current = turnId;
+    return {
+        composer: args.iface,
+        turnId,
+        signal: controller.signal,
+    };
+}
+/** Starts a turn from the composer's fields, or from an encoded draft (queued or send-now). */
+function useTurnStarters(args) {
+    const startTurnFromFields = useCallback(async (fields) => {
+        const started = beginAbortableTurn(args);
+        if (!started)
+            return;
+        await args.runTurnStream((view) => streamInterfaceTurn({
+            iface: started.composer,
+            transport: args.transport,
+            session: args.sessionRef.current,
+            text: fields.text,
+            pendingFiles: fields.files,
+            pendingVoice: fields.voice,
+            signal: started.signal,
+            turnId: started.turnId,
+            view,
+            onUserBlocks: (userBlocks) => {
+                args.setBlocks((prev) => [...prev, ...userBlocks]);
+                args.setDelivery({ status: 'sending' });
+                args.setChatStarted(true);
+                args.setStreaming(true);
+                args.clearComposer();
+            },
+        }), { userBlocksAlreadyApplied: true });
+    }, [args]);
+    const startTurnFromDraft = useCallback(async (draft, options = {}) => {
+        const started = beginAbortableTurn(args);
+        if (!started)
+            return;
+        await args.runTurnStream((view, paused) => streamInterfaceDraftTurn({
+            iface: started.composer,
+            transport: args.transport,
+            session: args.sessionRef.current,
+            draft,
+            signal: started.signal,
+            turnId: started.turnId,
+            view,
+            ...(options.walkAway ? { walkAway: paused } : {}),
+            onUserBlocks: (posted) => {
+                args.setBlocks((prev) => [...prev, ...posted]);
+                // A walked-away reply's blocks were streaming; they are posted now.
+                args.setStreamBlocks([]);
+                args.setDelivery({ status: 'sending' });
+                args.setChatStarted(true);
+                args.setStreaming(true);
+                options.onPosted?.();
+            },
+        }), { userBlocksAlreadyApplied: true, walksAway: options.walkAway === true });
+    }, [args]);
+    return { startTurnFromFields, startTurnFromDraft };
+}
+/** A steer with no running turn: the user reads `session.turn_ended`; queued steers move to the front. */
+function steerAfterTurnEnded(args, messageId) {
+    args.setFailure(clientFailure(
+    // lexicon-exempt: internal diagnostic; the user reads session.turn_ended
+    new TheoremError('request', 'steer: no active turn', { copy: { key: 'session.turn_ended' } }), args.iface?.lexicon));
+    args.setPendingMessages((prev) => orderComposerPendingMessages(convertSteersToFrontQueued(removeComposerPendingMessage(prev, messageId))));
+}
+/** Queue / steer / stash the composer draft, and restore a pending message into the composer. */
+function usePendingActions(args) {
+    const enqueuePending = useCallback(async (kind) => {
+        if (!userDraftHasPayload(composerFieldsPayload(args.draftText, args.pendingFiles, args.pendingVoice))) {
+            return;
+        }
+        args.setIssues([]);
+        try {
+            const draft = await encodeComposerDraft({
+                text: args.draftText,
+                pendingFiles: args.pendingFiles,
+                pendingVoice: args.pendingVoice,
+            });
+            const message = createComposerPendingMessage({ kind, draft });
+            args.setPendingMessages((prev) => orderComposerPendingMessages([...prev, message]));
+            args.clearComposer();
+            if (kind !== 'steer')
+                return;
+            const turnId = args.turnIdRef.current;
+            if (!turnId) {
+                steerAfterTurnEnded(args, message.id);
+                return;
+            }
+            const inject = userDraftToSteerInject(draft);
+            if (inject.length === 0)
+                return;
+            await args.transport.steer({ turnId, id: message.id, inject });
+        }
+        catch (err) {
+            args.setFailure(clientFailure(err, args.iface?.lexicon));
+        }
+    }, [args]);
+    const handlePendingRestore = useCallback(async (id) => {
+        const message = args.pendingRef.current.find((m) => m.id === id);
+        if (!message)
+            return;
+        const currentDraft = composerFieldsPayload(args.draftText, args.pendingFiles, args.pendingVoice);
+        try {
+            let nextPending = removeComposerPendingMessage(args.pendingRef.current, id);
+            if (userDraftHasPayload(currentDraft)) {
+                const stashDraft = await encodeComposerDraft({
+                    text: args.draftText,
+                    pendingFiles: args.pendingFiles,
+                    pendingVoice: args.pendingVoice,
+                });
+                const stash = createComposerPendingMessage({ kind: 'stash', draft: stashDraft });
+                nextPending = orderComposerPendingMessages([...nextPending, stash]);
+            }
+            const restored = composerFieldsFromDraft(message.draft);
+            args.setPendingMessages(nextPending);
+            args.setDraftText(restored.text);
+            args.setPendingFiles(restored.files);
+            args.setPendingVoice(restored.voice);
+            args.setIssues([]);
+        }
+        catch (err) {
+            args.setFailure(clientFailure(err, args.iface?.lexicon));
+        }
+    }, [args]);
+    return { enqueuePending, handlePendingRestore };
+}
+/** Answer the gate the session waits on: a decision, or a sign-in. */
+function useGateActions(args) {
+    const resumeGatedTool = useCallback(async (resolution) => {
+        const composer = args.iface;
+        if (!composer)
+            return;
+        // Set once the run starts (not while another runs), and cleared once it has ended.
+        let started = false;
+        try {
+            await args.runTurnStream((view) => {
+                started = true;
+                const session = args.sessionRef.current;
+                if (session.gatedTool)
+                    args.setAnswering({ callId: session.gatedTool.callId, action: resolution.action });
+                return resumeInterfaceTool({ iface: composer, transport: args.transport, session, resolution, view });
+            });
+        }
+        finally {
+            if (started)
+                args.setAnswering(null);
+        }
+    }, [args]);
+    const handleToolDecision = useCallback(async (_index, action) => {
+        await resumeGatedTool({ action });
+    }, [resumeGatedTool]);
+    const handleAuthenticated = useCallback(async (_index, secret) => {
+        await resumeGatedTool({ action: 'auth', ...(secret === undefined ? {} : { secret }) });
+    }, [resumeGatedTool]);
+    return { handleToolDecision, handleAuthenticated };
+}
+export function useTheoremChatActions(args) {
+    const { startTurnFromFields, startTurnFromDraft } = useTurnStarters(args);
+    const { enqueuePending, handlePendingRestore } = usePendingActions(args);
+    const { handleToolDecision, handleAuthenticated } = useGateActions(args);
+    const handleStop = useCallback(() => {
+        args.abortRef.current?.abort();
+    }, [args]);
+    const handleSubmit = useCallback(async () => {
+        if (args.phase === 'streaming' || args.phase === 'gated') {
+            await enqueuePending('queue');
+            return;
+        }
+        if (args.gated)
+            return;
+        args.setIssues([]);
+        await startTurnFromFields({
+            text: args.draftText,
+            files: [...args.pendingFiles],
+            voice: [...args.pendingVoice],
+        });
+    }, [args, enqueuePending, startTurnFromFields]);
+    /** The queued message's draft, or the composer's when it holds something to send. */
+    const draftToSend = useCallback(async (draftSource) => {
+        if (draftSource)
+            return draftSource.draft;
+        const draft = await encodeComposerDraft({
+            text: args.draftText,
+            pendingFiles: args.pendingFiles,
+            pendingVoice: args.pendingVoice,
+        });
+        return userDraftHasPayload(draft) ? draft : undefined;
+    }, [args]);
+    /** The sent message leaves the queue, or the composer it came from. */
+    const releaseDraft = useCallback((draftSource) => {
+        if (!draftSource) {
+            args.clearComposer();
+            return;
+        }
+        const pendingId = draftSource.id;
+        args.setPendingMessages((prev) => removeComposerPendingMessage(prev, pendingId));
+    }, [args]);
+    const handleSendNow = useCallback(async (draftSource) => {
+        if (!args.iface)
+            return;
+        const draft = await draftToSend(draftSource);
+        if (!draft)
+            return;
+        if (args.busyRef.current) {
+            args.abortRef.current?.abort();
+            await args.runPromiseRef.current;
+        }
+        args.setPendingMessages((prev) => convertSteersToFrontQueued(prev));
+        args.allowQueueDrainRef.current = false;
+        // Sent while the reply waits on gates, the message walks away from them in its own request.
+        await startTurnFromDraft(draft, {
+            walkAway: args.sessionRef.current.gatedTool !== null,
+            // The message leaves the composer (or the queue) once it posts.
+            onPosted: () => releaseDraft(draftSource),
+        });
+    }, [args, draftToSend, releaseDraft, startTurnFromDraft]);
+    const handleMenuAction = useCallback((action) => {
+        if (action === 'queue' || action === 'steer' || action === 'stash') {
+            void enqueuePending(action);
+            return;
+        }
+        if (action === 'send_now')
+            void handleSendNow();
+    }, [enqueuePending, handleSendNow]);
+    return {
+        startTurnFromFields,
+        startTurnFromDraft,
+        handleStop,
+        handleSubmit,
+        handleSendNow,
+        handleMenuAction,
+        handleToolDecision,
+        handleAuthenticated,
+        handlePendingRestore,
+        enqueuePending,
+    };
+}

package/hooks/use-theorem-chat-state.d.ts

@@ -0,0 +1,66 @@
+import { type AttachmentValidationIssue, type ComposerPendingMessage, type InterfaceTurnSession, type TranscriptBlock } from '@theoremjs/agents/interface';
+import type { ClientFailure } from '../client/failure.ts';
+import type { AnsweringGate } from '../client/tool-resume.ts';
+type SetSession = (value: InterfaceTurnSession | ((prev: InterfaceTurnSession) => InterfaceTurnSession)) => void;
+export type { SetSession };
+/**
+ * How far the latest message has got: posted (`sending`), taken by the server
+ * (`sent`), reached the model (`delivered`), answered (`read`).
+ */
+export type MessageDelivery = 'sending' | 'sent' | 'delivered' | 'read';
+/** A conversation at rest: what the transcript shows and what the next turn is sent with. */
+export type ChatSnapshot = {
+    blocks: TranscriptBlock[];
+    session: InterfaceTurnSession;
+};
+/** Composer / transcript / session state behind {@link useTheoremChat}. */
+export declare function useTheoremChatState(initial?: ChatSnapshot): {
+    blocks: TranscriptBlock[];
+    setBlocks: (value: TranscriptBlock[] | ((prev: TranscriptBlock[]) => TranscriptBlock[])) => void;
+    streamBlocks: TranscriptBlock[];
+    setStreamBlocks: import("react").Dispatch<import("react").SetStateAction<TranscriptBlock[]>>;
+    streamBlocksRef: import("react").RefObject<TranscriptBlock[]>;
+    draftText: string;
+    setDraftText: import("react").Dispatch<import("react").SetStateAction<string>>;
+    pendingFiles: File[];
+    setPendingFiles: import("react").Dispatch<import("react").SetStateAction<File[]>>;
+    pendingVoice: File[];
+    setPendingVoice: import("react").Dispatch<import("react").SetStateAction<File[]>>;
+    pendingMessages: ComposerPendingMessage[];
+    setPendingMessages: import("react").Dispatch<import("react").SetStateAction<ComposerPendingMessage[]>>;
+    issues: AttachmentValidationIssue[];
+    setIssues: import("react").Dispatch<import("react").SetStateAction<AttachmentValidationIssue[]>>;
+    failure: ClientFailure | null;
+    setFailure: import("react").Dispatch<import("react").SetStateAction<ClientFailure | null>>;
+    answering: AnsweringGate | null;
+    setAnswering: import("react").Dispatch<import("react").SetStateAction<AnsweringGate | null>>;
+    busy: boolean;
+    setBusy: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    chatStarted: boolean;
+    setChatStarted: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    streaming: boolean;
+    setStreaming: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    session: InterfaceTurnSession;
+    setSession: import("react").Dispatch<import("react").SetStateAction<InterfaceTurnSession>>;
+    delivery: {
+        status: MessageDelivery;
+    } | null;
+    setDelivery: (next: {
+        status: MessageDelivery;
+    } | null) => void;
+    deliveryRef: import("react").RefObject<{
+        status: MessageDelivery;
+    } | null>;
+    blocksRef: import("react").RefObject<TranscriptBlock[]>;
+    busyRef: import("react").RefObject<boolean>;
+    abortRef: import("react").RefObject<AbortController | null>;
+    turnIdRef: import("react").RefObject<string | null>;
+    pendingRef: import("react").RefObject<ComposerPendingMessage[]>;
+    sessionRef: import("react").RefObject<InterfaceTurnSession>;
+    drainLockRef: import("react").RefObject<boolean>;
+    allowQueueDrainRef: import("react").RefObject<boolean>;
+    runPromiseRef: import("react").RefObject<Promise<void> | null>;
+    cancelPendingStreamFrame: () => void;
+    scheduleStreamBlocks: (partial: TranscriptBlock[]) => void;
+    clearComposer: () => void;
+};