@theoremjs/react 0.3.4-next.373.gab46e23 → 0.3.4-next.377.g4dbec64

package/client/composer-hints.js

@@ -1,20 +0,0 @@
-/**
- * Composer hints — ephemeral guidance about the current composer interaction
- * (not pending-message state). Mirrors seance's `stash-selected-draft` hint.
- */
-/** Stash shortcut in Astryx `Kbd` notation (`mod` is ⌘ on macOS, Ctrl elsewhere). */
-export const STASH_SHORTCUT = 'mod+shift+s';
-/** Whether a keydown is the stash shortcut (⌘⇧S / Ctrl+Shift+S). */
-export function isStashShortcut(event) {
-    return (event.code === 'KeyS' && event.shiftKey && !event.altKey && (event.metaKey || event.ctrlKey));
-}
-/** The stash hint — shown while the whole draft is selected in the focused input and it can be stashed. */
-export function resolveComposerHint(args) {
-    const draft = args.draftText.trim();
-    if (!args.canStash || !draft || args.selectedText.trim() !== draft)
-        return null;
-    return {
-        id: 'stash-selected-draft',
-        shortcut: STASH_SHORTCUT,
-    };
-}

package/client/composer-primary.d.ts

@@ -1,16 +0,0 @@
-import { type ComposerMenuAction, type ComposerPrimaryAction, type ComposerProfileInterface, type ComposerRunPhase } from '@theoremjs/agents/interface';
-export type ComposerActionState = {
-    primary: ComposerPrimaryAction;
-    menuActions: ComposerMenuAction[];
-    /** Send is off while recording, with nothing to act on, or with an empty draft to send or queue. */
-    primaryDisabled: boolean;
-};
-/** The composer's primary button and send menu for the current draft and run phase. */
-export declare function composerActionState(args: {
-    iface: ComposerProfileInterface;
-    phase: ComposerRunPhase;
-    draftText: string;
-    pendingFiles: readonly File[];
-    pendingVoice: readonly File[];
-    recording: boolean;
-}): ComposerActionState;

package/client/composer-primary.js

@@ -1,25 +0,0 @@
-import { resolveComposerMenuActions, resolveComposerPrimary, userDraftHasPayload, } from '@theoremjs/agents/interface';
-function fileSpecs(files) {
-    return files.map((file) => ({
-        name: file.name,
-        mimeType: file.type || 'application/octet-stream',
-        sizeBytes: file.size,
-    }));
-}
-/** The composer's primary button and send menu for the current draft and run phase. */
-export function composerActionState(args) {
-    const allowSteering = 'allowSteering' in args.iface && Boolean(args.iface.allowSteering);
-    const hasPayload = userDraftHasPayload({
-        ...(args.draftText.trim() ? { text: args.draftText } : {}),
-        ...(args.pendingFiles.length ? { attachments: fileSpecs(args.pendingFiles) } : {}),
-        ...(args.pendingVoice.length ? { voice: fileSpecs(args.pendingVoice) } : {}),
-    });
-    const context = { phase: args.phase, hasPayload, allowSteering };
-    const primary = resolveComposerPrimary(context);
-    const needsPayload = primary === 'send' || primary === 'queue';
-    return {
-        primary,
-        menuActions: resolveComposerMenuActions(context),
-        primaryDisabled: args.recording || primary === 'none' || (needsPayload && !hasPayload),
-    };
-}

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

@@ -1,77 +0,0 @@
-import type { AttachmentValidationIssue, ComposerMenuAction, ComposerPendingMessage, ComposerProfileInterface, ComposerRunPhase, InterfaceTurnSession, TranscriptBlock } from '@theoremjs/agents/interface';
-import type { RunOutcome, TheoremTransport } from '@theoremjs/web/client';
-import { type AnsweringGate, type ClientFailure, type StreamView, type ToolDecisionAction, type ToolGateResolution } from '@theoremjs/web/client';
-import { type MutableRefObject } from 'react';
-import type { MessageDelivery } from './use-theorem-chat-state.ts';
-export type RunTurnStream = (run: (view: StreamView) => Promise<RunOutcome>, options?: {
-    /** The run sends a message: one that never posts goes back in the composer with its failure. */
-    message?: {
-        restore(): Promise<void>;
-    };
-}) => Promise<void>;
-export type TheoremChatActionArgs = {
-    iface: ComposerProfileInterface | null;
-    transport: TheoremTransport;
-    phase: ComposerRunPhase;
-    gated: boolean;
-    draftText: string;
-    pendingFiles: File[];
-    pendingVoice: File[];
-    /** The composer as it is now, for a run that ends after it changed. */
-    composerRef: MutableRefObject<{
-        draftText: string;
-        pendingFiles: File[];
-        pendingVoice: File[];
-    }>;
-    /** The ref of the conversation the chat continues; none before its first message posts. */
-    conversationRef: MutableRefObject<string | undefined>;
-    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[]>;
-};
-type ComposerFields = {
-    text: string;
-    files: File[];
-    voice: File[];
-};
-export declare function useTheoremChatActions(args: TheoremChatActionArgs): {
-    startTurnFromFields: (fields: ComposerFields) => 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>;
-    resumeGatedTool: (resolution: ToolGateResolution) => Promise<void>;
-    handlePendingRestore: (id: string) => Promise<void>;
-    enqueuePending: (kind: "queue" | "steer" | "stash") => Promise<void>;
-};
-export {};

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

@@ -1,285 +0,0 @@
-import { TheoremError } from '@theoremjs/agents';
-import { convertSteersToFrontQueued, createComposerPendingMessage, orderComposerPendingMessages, removeComposerPendingMessage, userDraftHasPayload, userDraftToSteerInject, } from '@theoremjs/agents/interface';
-import { clientFailure, composerFieldsFromDraft, encodeComposerDraft, issuedOperationId, resumeInterfaceTool, streamInterfaceDraftTurn, streamInterfaceTurn, } from '@theoremjs/web/client';
-import { useCallback } from 'react';
-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,
-    };
-}
-/** The run's scope: the conversation the chat continues, and the run's own turn. */
-function scopeOf(args, turnId) {
-    return { conversation: args.conversationRef.current, turnId };
-}
-/**
- * Puts a message back in the composer. What the composer holds now is
- * stashed first, so nothing the user typed is lost.
- */
-function useRestoreToComposer(args) {
-    return useCallback(async (fields) => {
-        const { draftText, pendingFiles, pendingVoice } = args.composerRef.current;
-        if (userDraftHasPayload(composerFieldsPayload(draftText, pendingFiles, pendingVoice))) {
-            const draft = await encodeComposerDraft({ text: draftText, pendingFiles, pendingVoice });
-            const stash = createComposerPendingMessage({ kind: 'stash', draft });
-            args.setPendingMessages((prev) => orderComposerPendingMessages([...prev, stash]));
-        }
-        args.setDraftText(fields.text);
-        args.setPendingFiles(fields.files);
-        args.setPendingVoice(fields.voice);
-        args.setIssues([]);
-    }, [args]);
-}
-/** Starts a turn from the composer's fields, or from an encoded draft (queued or send-now). */
-function useTurnStarters(args, restoreToComposer) {
-    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,
-            scope: scopeOf(args, started.turnId),
-            view,
-            transcript: args.blocksRef.current,
-            onUserBlocks: (userBlocks) => {
-                args.setBlocks((prev) => [...prev, ...userBlocks]);
-                args.setDelivery({ status: 'sending' });
-                args.setChatStarted(true);
-                args.setStreaming(true);
-                args.clearComposer();
-            },
-        }), { message: { restore: () => restoreToComposer(fields) } });
-    }, [args, restoreToComposer]);
-    const startTurnFromDraft = useCallback(async (draft, options = {}) => {
-        const started = beginAbortableTurn(args);
-        if (!started)
-            return;
-        await args.runTurnStream((view) => streamInterfaceDraftTurn({
-            iface: started.composer,
-            transport: args.transport,
-            session: args.sessionRef.current,
-            draft,
-            signal: started.signal,
-            scope: scopeOf(args, started.turnId),
-            view,
-            transcript: args.blocksRef.current,
-            walkAway: options.walkAway === true,
-            onUserBlocks: (posted) => {
-                args.setBlocks((prev) => [...prev, ...posted]);
-                args.setStreamBlocks([]);
-                args.setDelivery({ status: 'sending' });
-                args.setChatStarted(true);
-                args.setStreaming(true);
-                options.onPosted?.();
-            },
-        }), { message: { restore: () => restoreToComposer(composerFieldsFromDraft(draft)) } });
-    }, [args, restoreToComposer]);
-    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(
-    // labels-exempt: internal diagnostic; the user reads session.turn_ended
-    new TheoremError('request', 'steer: no active turn', { copy: { key: 'session.turn_ended' } }), args.iface?.labels));
-    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, restoreToComposer) {
-    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?.labels));
-        }
-    }, [args]);
-    const handlePendingRestore = useCallback(async (id) => {
-        const message = args.pendingRef.current.find((m) => m.id === id);
-        if (!message)
-            return;
-        try {
-            await restoreToComposer(composerFieldsFromDraft(message.draft));
-            args.setPendingMessages((prev) => removeComposerPendingMessage(prev, id));
-        }
-        catch (err) {
-            args.setFailure(clientFailure(err, args.iface?.labels));
-        }
-    }, [args, restoreToComposer]);
-    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;
-        // why: 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;
-                // why: A person's answer shows on its gate while it settles; the page's has no gate to show on.
-                if (session.gatedTool && resolution.action !== 'page')
-                    args.setAnswering({
-                        callId: session.gatedTool.callId,
-                        operationId: issuedOperationId(session.gatedTool),
-                        action: resolution.action,
-                    });
-                return resumeInterfaceTool({
-                    iface: composer,
-                    transport: args.transport,
-                    session,
-                    scope: scopeOf(args),
-                    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, resumeGatedTool };
-}
-export function useTheoremChatActions(args) {
-    const restoreToComposer = useRestoreToComposer(args);
-    const { startTurnFromFields, startTurnFromDraft } = useTurnStarters(args, restoreToComposer);
-    const { enqueuePending, handlePendingRestore } = usePendingActions(args, restoreToComposer);
-    const { handleToolDecision, handleAuthenticated, resumeGatedTool } = 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;
-        // why: 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,
-            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,
-        resumeGatedTool,
-        handlePendingRestore,
-        enqueuePending,
-    };
-}

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

@@ -1,65 +0,0 @@
-import { type AttachmentValidationIssue, type ComposerPendingMessage, type InterfaceTurnSession, type TranscriptBlock } from '@theoremjs/agents/interface';
-import type { AnsweringGate, ClientFailure } from '@theoremjs/web/client';
-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';
-/** Composer / transcript / session state behind {@link useTheoremChat}. */
-export declare function useTheoremChatState(initialText?: string): {
-    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>;
-    composerRef: import("react").RefObject<{
-        draftText: string;
-        pendingFiles: File[];
-        pendingVoice: File[];
-    }>;
-    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;
-};

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

@@ -1,122 +0,0 @@
-import { emptyInterfaceTurnSession, } from '@theoremjs/agents/interface';
-import { useCallback, useRef, useState } from 'react';
-/** Coalesces streamed partial blocks to one state update per animation frame. */
-function useStreamFrames(setStreamBlocks) {
-    const streamRafRef = useRef(null);
-    const pendingStreamRef = useRef(null);
-    const cancelPendingStreamFrame = useCallback(() => {
-        if (streamRafRef.current != null) {
-            cancelAnimationFrame(streamRafRef.current);
-            streamRafRef.current = null;
-        }
-        pendingStreamRef.current = null;
-    }, []);
-    const scheduleStreamBlocks = useCallback((partial) => {
-        pendingStreamRef.current = partial;
-        if (streamRafRef.current != null)
-            return;
-        streamRafRef.current = requestAnimationFrame(() => {
-            streamRafRef.current = null;
-            const next = pendingStreamRef.current;
-            pendingStreamRef.current = null;
-            if (next)
-                setStreamBlocks(next);
-        });
-    }, [setStreamBlocks]);
-    return { cancelPendingStreamFrame, scheduleStreamBlocks };
-}
-/** Composer / transcript / session state behind {@link useTheoremChat}. */
-export function useTheoremChatState(initialText = '') {
-    const [blocks, setBlocksState] = useState([]);
-    const [streamBlocks, setStreamBlocks] = useState([]);
-    const [draftText, setDraftText] = useState(initialText);
-    const [pendingFiles, setPendingFiles] = useState([]);
-    const [pendingVoice, setPendingVoice] = useState([]);
-    const [pendingMessages, setPendingMessages] = useState([]);
-    const [issues, setIssues] = useState([]);
-    const [failure, setFailure] = useState(null);
-    const [answering, setAnswering] = useState(null);
-    const [busy, setBusy] = useState(false);
-    const [chatStarted, setChatStarted] = useState(false);
-    const [streaming, setStreaming] = useState(false);
-    const [session, setSession] = useState(emptyInterfaceTurnSession);
-    // why: One object per posted message, so a run can tell whether it posted one.
-    const [delivery, setDeliveryState] = useState(null);
-    const blocksRef = useRef(blocks);
-    // why: Set as it is written, so a caller awaiting a turn reads the transcript the turn left.
-    const setBlocks = useCallback((value) => {
-        blocksRef.current = typeof value === 'function' ? value(blocksRef.current) : value;
-        setBlocksState(blocksRef.current);
-    }, []);
-    const streamBlocksRef = useRef(streamBlocks);
-    streamBlocksRef.current = streamBlocks;
-    const busyRef = useRef(false);
-    const abortRef = useRef(null);
-    const turnIdRef = useRef(null);
-    const pendingRef = useRef(pendingMessages);
-    pendingRef.current = pendingMessages;
-    const sessionRef = useRef(session);
-    sessionRef.current = session;
-    const drainLockRef = useRef(false);
-    const allowQueueDrainRef = useRef(false);
-    const runPromiseRef = useRef(null);
-    const deliveryRef = useRef(delivery);
-    // why: A run's end reads the composer as it is then, not as it was when the run began.
-    const composerRef = useRef({ draftText, pendingFiles, pendingVoice });
-    composerRef.current = { draftText, pendingFiles, pendingVoice };
-    const setDelivery = useCallback((next) => {
-        deliveryRef.current = next;
-        setDeliveryState(next);
-    }, []);
-    const { cancelPendingStreamFrame, scheduleStreamBlocks } = useStreamFrames(setStreamBlocks);
-    const clearComposer = useCallback(() => {
-        setDraftText('');
-        setPendingFiles([]);
-        setPendingVoice([]);
-    }, []);
-    return {
-        blocks,
-        setBlocks,
-        streamBlocks,
-        setStreamBlocks,
-        streamBlocksRef,
-        draftText,
-        setDraftText,
-        pendingFiles,
-        setPendingFiles,
-        pendingVoice,
-        setPendingVoice,
-        pendingMessages,
-        setPendingMessages,
-        issues,
-        setIssues,
-        failure,
-        setFailure,
-        answering,
-        setAnswering,
-        busy,
-        setBusy,
-        chatStarted,
-        setChatStarted,
-        streaming,
-        setStreaming,
-        session,
-        setSession,
-        delivery,
-        setDelivery,
-        deliveryRef,
-        composerRef,
-        blocksRef,
-        busyRef,
-        abortRef,
-        turnIdRef,
-        pendingRef,
-        sessionRef,
-        drainLockRef,
-        allowQueueDrainRef,
-        runPromiseRef,
-        cancelPendingStreamFrame,
-        scheduleStreamBlocks,
-        clearComposer,
-    };
-}