@theoremjs/react 0.3.4-next.363.g11be542 → 0.3.4-next.375.ga2d1878

package/client/turn-client.js

@@ -1,88 +0,0 @@
-import { labelText, TheoremError } from '@theoremjs/agents';
-import { foldTurnEvents, prepareUserTurn, streamThoughtsEnabled, } from '@theoremjs/agents/interface';
-import { filesToPending } from "./encode-files.js";
-import { defaultModel } from "./generation-selection.js";
-export function issuedOperationId(call) {
-    if (!call.operationId)
-        throw new TheoremError('request', labelText('session.gate_expired'));
-    return call.operationId;
-}
-function resolveModelId(iface, session) {
-    return session.selectedModel ?? defaultModel(iface);
-}
-function resolveEffort(iface, session, modelId) {
-    if (!modelId || !Object.hasOwn(iface.models, modelId))
-        return undefined;
-    const binding = iface.models[modelId];
-    if (!binding.allowEffortSelect)
-        return undefined;
-    return session.selectedEffort ?? binding.defaultEffort;
-}
-/** Model / effort selection the host should honour for this session. */
-function generationFields(iface, session) {
-    const modelId = resolveModelId(iface, session);
-    const model = iface.allowModelSelect ? modelId : undefined;
-    const effort = resolveEffort(iface, session, modelId);
-    return { ...(model ? { model } : {}), ...(effort ? { effort } : {}) };
-}
-function gateReplay(iface, session, call) {
-    return {
-        name: call.name,
-        input: call.input,
-        ...(call.gateKind ? { gateKind: call.gateKind } : {}),
-        sessionPermissions: call.sessionPermissions ?? session.sessionPermissions,
-        ...(session.toolSnapshot ? { snapshot: session.toolSnapshot } : {}),
-        ...(session.promotedToolIds.length ? { promoted: [...session.promotedToolIds] } : {}),
-        ...generationFields(iface, session),
-    };
-}
-function scopeFields(scope) {
-    return {
-        ...(scope.conversation ? { conversation: scope.conversation } : {}),
-        ...(scope.turnId ? { turnId: scope.turnId } : {}),
-    };
-}
-export function buildTurnRequest(iface, session, input, options = {}) {
-    const abandon = (options.walkAway?.calls ?? []).map((call) => ({
-        callId: call.callId,
-        operationId: issuedOperationId(call),
-    }));
-    return {
-        ...scopeFields(options),
-        ...generationFields(iface, session),
-        input,
-        ...(abandon.length ? { abandon } : {}),
-        replay: { sessionPermissions: session.sessionPermissions },
-    };
-}
-export function buildInvokeRequest(iface, session, args, scope = {}) {
-    return {
-        ...scopeFields(scope),
-        gateId: args.gateId,
-        operationId: args.operationId,
-        decision: args.decision,
-        ...(args.secret === undefined ? {} : { secret: args.secret }),
-        ...(args.page === undefined ? {} : { page: args.page }),
-        replay: gateReplay(iface, session, {
-            ...args,
-            gateKind: args.gateKind ??
-                (session.gatedTool?.callId === args.gateId ? session.gatedTool.gateKind : undefined),
-        }),
-    };
-}
-export function projectUserTurn(iface, draft) {
-    return prepareUserTurn(iface.inputs, draft, iface.guardrails);
-}
-export function prepareComposerTurn(iface, text, pendingFiles, pendingVoice = []) {
-    return projectUserTurn(iface, {
-        ...(text.trim() ? { text } : {}),
-        ...(pendingFiles.length ? { attachments: filesToPending(pendingFiles) } : {}),
-        ...(pendingVoice.length ? { voice: filesToPending(pendingVoice) } : {}),
-    });
-}
-export function foldAssistantTurn(iface, events) {
-    // why: Its `turn-done` blocks stay: hidden in the view, they carry the reply's worked time.
-    return foldTurnEvents(events, {
-        showThoughts: streamThoughtsEnabled(iface.outputs),
-    });
-}

package/client/wire-line.d.ts

@@ -1,56 +0,0 @@
-/**
- * Every value that reaches the browser over a wire (NDJSON lines, live
- * envelopes) is checked against its schema here. A line or event of a kind the
- * client does not know is reported as `unsupported`, and one that fails its
- * check (not JSON, no kind, or a known kind that fails its schema) as
- * `malformed`; either way the reply goes on. A whole reply that fails its check
- * (the profile description) is `bad_response`.
- *
- * @module
- */
-import { TheoremError, z } from '@theoremjs/agents';
-/**
- * A line or envelope of a kind the client does not know. The server never
- * sends it; the client's parser makes it so the host sees what arrived. Theorem
- * shows nothing for it.
- */
-export type UnsupportedEvent = {
-    type: 'unsupported';
-    received: string;
-    raw: unknown;
-};
-/**
- * A line or event that failed its wire check. The server never sends it; the
- * client's reader makes it, leaves the line out, and the reply goes on. `error`
- * is `bad_response`: its message names what broke, never the value, and the
- * user reads `session.part_skipped`.
- */
-export type MalformedEvent = {
-    type: 'malformed';
-    error: TheoremError;
-};
-/** Every kind a wire carries, and the schema a value of that kind must pass. */
-export type WireLines<Line extends {
-    type: string;
-}> = {
-    readonly [K in Line['type']]: z.ZodType<Extract<Line, {
-        type: K;
-    }>>;
-};
-/**
- * Issue paths and codes only: a failure names what broke, never the value. A
- * union that matched no branch lists each branch's issues.
- */
-export declare function issueSummary(error: z.ZodError): string;
-/** `raw` as `schema` reads it; one that fails is `bad_response`, naming `what`. */
-export declare function checkWire<T>(schema: z.ZodType<T>, raw: unknown, what: string): T;
-/** One wire value: a known kind that passed its schema, `unsupported`, or `malformed`. */
-export declare function readWireValue<Line extends {
-    type: string;
-}>(lines: WireLines<Line>, raw: unknown): Line | UnsupportedEvent | MalformedEvent;
-/** One wire line's text: {@link readWireValue} of its JSON, or `malformed` when it is not JSON. */
-export declare function readWireLine<Line extends {
-    type: string;
-}>(lines: WireLines<Line>, text: string): Line | UnsupportedEvent | MalformedEvent;
-/** A whole reply's JSON text as a value; text that is not JSON is `bad_response`. */
-export declare function parseWireJson(text: string): unknown;

package/client/wire-line.js

@@ -1,90 +0,0 @@
-/**
- * Every value that reaches the browser over a wire (NDJSON lines, live
- * envelopes) is checked against its schema here. A line or event of a kind the
- * client does not know is reported as `unsupported`, and one that fails its
- * check (not JSON, no kind, or a known kind that fails its schema) as
- * `malformed`; either way the reply goes on. A whole reply that fails its check
- * (the profile description) is `bad_response`.
- *
- * @module
- */
-import { TheoremError, z } from '@theoremjs/agents';
-const wireKind = z.object({ type: z.string() });
-function isKnown(lines, type) {
-    return Object.hasOwn(lines, type);
-}
-function issuesSummary(issues, at) {
-    return issues
-        .map((issue) => {
-        const path = [...at, ...issue.path];
-        const head = `${path.map(String).join('.') || '(root)'} ${issue.code}`;
-        if (issue.code !== 'invalid_union' || issue.errors.length === 0)
-            return head;
-        return `${head} [${issue.errors.map((branch) => issuesSummary(branch, path)).join(' | ')}]`;
-    })
-        .join('; ');
-}
-/**
- * Issue paths and codes only: a failure names what broke, never the value. A
- * union that matched no branch lists each branch's issues.
- */
-export function issueSummary(error) {
-    return issuesSummary(error.issues, []);
-}
-function badResponse(what, error) {
-    // labels-exempt: internal diagnostic; the user reads error.bad_response
-    return new TheoremError('bad_response', `${what} failed its wire check: ${issueSummary(error)}`);
-}
-/** `raw` as `schema` reads it; one that fails is `bad_response`, naming `what`. */
-export function checkWire(schema, raw, what) {
-    const parsed = schema.safeParse(raw);
-    if (!parsed.success)
-        throw badResponse(what, parsed.error);
-    return parsed.data;
-}
-function malformed(message) {
-    return {
-        type: 'malformed',
-        error: new TheoremError('bad_response', message, { copy: { key: 'session.part_skipped' } }),
-    };
-}
-/** One wire value: a known kind that passed its schema, `unsupported`, or `malformed`. */
-export function readWireValue(lines, raw) {
-    const kind = wireKind.safeParse(raw);
-    // labels-exempt: internal diagnostic; the user reads session.part_skipped
-    if (!kind.success)
-        return malformed(`a line without a kind failed its wire check: ${issueSummary(kind.error)}`);
-    const { type } = kind.data;
-    if (!isKnown(lines, type))
-        return { type: 'unsupported', received: type, raw };
-    const line = lines[type].safeParse(raw);
-    if (line.success)
-        return line.data;
-    // labels-exempt: internal diagnostic; the user reads session.part_skipped
-    return malformed(`a '${type}' line failed its wire check: ${issueSummary(line.error)}`);
-}
-/** JSON text as a value, or undefined when it is not JSON. The parser's own error quotes the text, so it is not kept. */
-function jsonValue(text) {
-    try {
-        return { value: JSON.parse(text) };
-    }
-    catch (err) {
-        if (err instanceof SyntaxError)
-            return undefined;
-        throw err;
-    }
-}
-/** One wire line's text: {@link readWireValue} of its JSON, or `malformed` when it is not JSON. */
-export function readWireLine(lines, text) {
-    const json = jsonValue(text);
-    // labels-exempt: internal diagnostic; the user reads session.part_skipped
-    return json ? readWireValue(lines, json.value) : malformed('a line is not JSON');
-}
-/** A whole reply's JSON text as a value; text that is not JSON is `bad_response`. */
-export function parseWireJson(text) {
-    const json = jsonValue(text);
-    // labels-exempt: internal diagnostic; the user reads error.bad_response
-    if (!json)
-        throw new TheoremError('bad_response', 'a line is not JSON');
-    return json.value;
-}

package/client/worklets/mic-capture.js

@@ -1,16 +0,0 @@
-/**
- * AudioWorklet processor that forwards mono mic frames to the main thread.
- * Plain JS: it runs in the AudioWorkletGlobalScope as its own module, loaded
- * by URL (see `../mic-capture.ts`), so it imports nothing and ships as is.
- */
-registerProcessor(
-  'mic-capture-processor',
-  class MicCaptureProcessor extends AudioWorkletProcessor {
-    process(inputs) {
-      const channel = inputs[0][0];
-      const copy = new Float32Array(channel);
-      this.port.postMessage(copy, [copy.buffer]);
-      return true;
-    }
-  },
-);

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

@@ -1,79 +0,0 @@
-import type { AttachmentValidationIssue, ComposerMenuAction, ComposerPendingMessage, ComposerProfileInterface, ComposerRunPhase, InterfaceTurnSession, TranscriptBlock } from '@theoremjs/agents/interface';
-import { type MutableRefObject } from 'react';
-import { type ClientFailure } from '../client/failure.ts';
-import { type AnsweringGate, type StreamView, type ToolDecisionAction, type ToolGateResolution } from '../client/index.ts';
-import type { RunOutcome } from '../client/run-session.ts';
-import type { TheoremTransport } from '../client/transport.ts';
-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,287 +0,0 @@
-import { TheoremError } from '@theoremjs/agents';
-import { convertSteersToFrontQueued, createComposerPendingMessage, orderComposerPendingMessages, removeComposerPendingMessage, userDraftHasPayload, userDraftToSteerInject, } from '@theoremjs/agents/interface';
-import { useCallback } from 'react';
-import { clientFailure } from "../client/failure.js";
-import { composerFieldsFromDraft, encodeComposerDraft, resumeInterfaceTool, streamInterfaceDraftTurn, streamInterfaceTurn, } from "../client/index.js";
-import { issuedOperationId } from "../client/turn-client.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,
-    };
-}
-/** 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,
-    };
-}