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

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

@@ -1,66 +0,0 @@
-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';
-/** 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,
-    };
-}

package/server/checkpoint-ownership.d.ts

@@ -1,6 +0,0 @@
-import { type ProviderCheckpoint, type TurnHistoryMessage } from '@theoremjs/agents';
-import type { TheoremSessionState } from './session-store.ts';
-export declare function checkpointIdentity(checkpoint: ProviderCheckpoint): Promise<string>;
-export declare function checkpointOwnershipKey(identity: string, operations: TheoremSessionState['operations']): Promise<string>;
-export declare function requireOwnedCheckpoint(identities: readonly string[], checkpoint: ProviderCheckpoint | undefined, operations?: TheoremSessionState['operations'], portableHistory?: readonly TurnHistoryMessage[]): Promise<ProviderCheckpoint | undefined>;
-export declare function retainedCheckpointIdentities(existing: readonly string[], added: readonly string[], limit: number): string[];

package/server/checkpoint-ownership.js

@@ -1,42 +0,0 @@
-import { labelText, providerCheckpointSchema, TheoremError, toolInvocationHash, } from '@theoremjs/agents';
-export function checkpointIdentity(checkpoint) {
-    return toolInvocationHash(providerCheckpointSchema.parse(checkpoint));
-}
-export async function checkpointOwnershipKey(identity, operations) {
-    const rows = Object.entries(operations)
-        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0))
-        .map(([id, operation]) => operation.status === 'ready'
-        ? [id, operation.status, operation.profileId, operation.readyAt]
-        : [id, operation.status, operation.profileId, operation.toolId, operation.invocationHash]);
-    const epoch = await toolInvocationHash(rows);
-    return `${identity}:${epoch}`;
-}
-export async function requireOwnedCheckpoint(identities, checkpoint, operations = {}, portableHistory) {
-    if (checkpoint === undefined)
-        return undefined;
-    const parsed = providerCheckpointSchema.parse(checkpoint);
-    const identity = await checkpointIdentity(parsed);
-    const key = await checkpointOwnershipKey(identity, operations);
-    const records = Object.values(operations);
-    const portableSettlements = portableHistory !== undefined &&
-        records.length > 0 &&
-        identities.some((saved) => saved.startsWith(`${identity}:`)) &&
-        records.every((operation) => operation.status === 'settled' &&
-            operation.outcome.effects !== 'unknown' &&
-            operation.outcome.event.tool.readBack !== undefined &&
-            portableHistory.some((message) => message.role === 'tool' &&
-                message.tool_call_id === operation.callId &&
-                message.name === operation.toolId &&
-                message.content === operation.outcome.event.tool.readBack));
-    if (!identities.includes(key) &&
-        !portableSettlements &&
-        !(records.length === 0 && identities.includes(identity))) {
-        throw new TheoremError('request', labelText('session.provider_state_unowned'), {
-            copy: { key: 'session.provider_state_unowned' },
-        });
-    }
-    return parsed;
-}
-export function retainedCheckpointIdentities(existing, added, limit) {
-    return [...new Set([...existing, ...added].reverse())].slice(0, limit).reverse();
-}

package/server/conversation-store.d.ts

@@ -1,92 +0,0 @@
-/**
- * Where a chat's conversation lives for `createTheoremHandler`: the transcript
- * the person reads and the history the model reads next. The host owns it; the
- * browser holds only an opaque ref the store issued, and never sends history.
- *
- * A database store keys the conversation by its id. The sealed store keeps
- * nothing: its ref is the conversation itself, encrypted and signed with the
- * host's key, so the browser carries what it cannot read or change.
- *
- * @module
- */
-import { type ProviderCheckpoint, TheoremError, type TurnEvent, type TurnHistoryMessage, z } from '@theoremjs/agents';
-import type { TranscriptBlock } from '@theoremjs/agents/interface';
-import { type MemorySessionStoreOptions } from './session-store.ts';
-/** A reply paused on gates: its events so far, and the history it was given. */
-export type PausedReply = {
-    events: TurnEvent[];
-    /** The history the reply was given; its events append to this when it commits. */
-    base: TurnHistoryMessage[];
-    /** How many of `events` `base` already holds: a compaction mid-reply moves the base. */
-    baseEvents: number;
-    /** How long the reply worked before it paused (ms), approval waits excluded. */
-    workedMs: number;
-    /** When the reply last paused (epoch ms). */
-    endedAt: number;
-    /** The model and effort the reply ran with, for the run that goes on after its gates. */
-    model?: string;
-    effort?: string;
-};
-/** One conversation as the host stores it. */
-export type StoredConversation = {
-    version: 1;
-    /** What the person reads, without the paused reply. */
-    transcript: TranscriptBlock[];
-    /** What the model reads on the next turn, compacted when the profile compacts. */
-    history: TurnHistoryMessage[];
-    providerState?: ProviderCheckpoint;
-    /** The last turn's input tokens, for the compaction meter. */
-    inputTokens?: number;
-    /** The history's size in tokens as the last compaction measured it. */
-    historyTokens?: number;
-    paused?: PausedReply;
-};
-/** A stored conversation as a host's own store reads it back. */
-export declare const storedConversationSchema: z.ZodType<StoredConversation>;
-/** An empty conversation: what a chat with no ref starts from. */
-export declare function emptyConversation(): StoredConversation;
-export interface ConversationSnapshot {
-    revision: string;
-    conversation: StoredConversation;
-}
-export type ConversationWriteResult = {
-    written: true;
-    ref: string;
-    revision: string;
-} | {
-    written: false;
-};
-/**
- * Where conversations live. `ref` is the store's own: the handler hands it to
- * the browser and back, and never reads it. Every read and write names the
- * session, so a ref from another session opens nothing.
- */
-export interface TheoremConversationStore {
-    /** The conversation, or undefined when this session has none under `ref`. */
-    read(sessionId: string, ref: string): Promise<ConversationSnapshot | undefined>;
-    /**
-     * Compare and replace. A null `ref` creates a conversation; otherwise the
-     * write lands only on a conversation this session can read, while its
-     * stored revision is still `expectedRevision`.
-     */
-    write(sessionId: string, ref: string | null, expectedRevision: string | null, next: StoredConversation): Promise<ConversationWriteResult>;
-}
-/** Refuses a ref the store does not know or cannot open: the browser reads `session.conversation_unknown`. */
-export declare function unknownConversation(cause?: unknown): TheoremError;
-/** Conversations in process memory: forgotten when idle, oldest evicted first. For one instance. */
-export declare function createMemoryConversationStore(options?: Omit<MemorySessionStoreOptions, 'sessionLimits'>): TheoremConversationStore;
-export type SealedConversationStoreOptions = {
-    /** Every sealing key still in use, by version: each at least 32 bytes, kept off the browser. */
-    keys: Readonly<Record<number, string>>;
-    /** The key that seals new writes. */
-    keyVersion: number;
-};
-/**
- * A store for a host that keeps nothing. The ref is the conversation sealed
- * with the host's key and bound to the session: the browser carries it and
- * cannot read or change it, and it opens in no other session.
- *
- * It cannot tell an older seal from the newest, so an older seal opens: like a
- * rewind, it returns a conversation the host wrote. Its revision is the seal.
- */
-export declare function createSealedConversationStore(options: SealedConversationStoreOptions): TheoremConversationStore;

package/server/conversation-store.js

@@ -1,131 +0,0 @@
-/**
- * Where a chat's conversation lives for `createTheoremHandler`: the transcript
- * the person reads and the history the model reads next. The host owns it; the
- * browser holds only an opaque ref the store issued, and never sends history.
- *
- * A database store keys the conversation by its id. The sealed store keeps
- * nothing: its ref is the conversation itself, encrypted and signed with the
- * host's key, so the browser carries what it cannot read or change.
- *
- * @module
- */
-import { labelText, providerCheckpointSchema, TheoremError, turnEventSchema, turnHistoryMessageSchema, z, } from '@theoremjs/agents';
-import { openSecret, sealSecret } from '@theoremjs/agents/kernel';
-import { transcriptBlockSchema } from "../client/transcript-schema.js";
-import { memoryStoreLimits } from "./session-store.js";
-const pausedReply = z.object({
-    events: z.array(turnEventSchema),
-    base: z.array(turnHistoryMessageSchema),
-    baseEvents: z.number().int().nonnegative(),
-    workedMs: z.number().nonnegative(),
-    endedAt: z.number(),
-    model: z.string().optional(),
-    effort: z.string().optional(),
-});
-true;
-const storedConversation = z.object({
-    version: z.literal(1),
-    transcript: z.array(transcriptBlockSchema),
-    history: z.array(turnHistoryMessageSchema),
-    providerState: providerCheckpointSchema.optional(),
-    inputTokens: z.number().optional(),
-    historyTokens: z.number().optional(),
-    paused: pausedReply.optional(),
-});
-true;
-/** A stored conversation as a host's own store reads it back. */
-export const storedConversationSchema = storedConversation;
-/** An empty conversation: what a chat with no ref starts from. */
-export function emptyConversation() {
-    return { version: 1, transcript: [], history: [] };
-}
-/** Refuses a ref the store does not know or cannot open: the browser reads `session.conversation_unknown`. */
-export function unknownConversation(cause) {
-    return new TheoremError('request', labelText('session.conversation_unknown'), {
-        copy: { key: 'session.conversation_unknown' },
-        ...(cause === undefined ? {} : { cause }),
-    });
-}
-/** Conversations in process memory: forgotten when idle, oldest evicted first. For one instance. */
-export function createMemoryConversationStore(options = {}) {
-    const { ttlMs, maxSessions } = memoryStoreLimits(options);
-    const conversations = new Map();
-    const current = (sessionId, ref) => {
-        const entry = conversations.get(ref);
-        if (!entry || entry.sessionId !== sessionId)
-            return undefined;
-        if (Date.now() - entry.touched >= ttlMs) {
-            conversations.delete(ref);
-            return undefined;
-        }
-        return entry.snapshot;
-    };
-    const written = (...[sessionId, ref, expectedRevision, next]) => {
-        const snapshot = ref === null ? undefined : current(sessionId, ref);
-        // invariant: A ref this session cannot read takes no write, so no session overwrites another's conversation.
-        if (ref !== null && snapshot === undefined)
-            return { written: false };
-        if ((snapshot?.revision ?? null) !== expectedRevision)
-            return { written: false };
-        const conversation = storedConversation.parse(next);
-        const key = ref ?? crypto.randomUUID();
-        const revision = crypto.randomUUID();
-        conversations.delete(key);
-        conversations.set(key, {
-            sessionId,
-            snapshot: { revision, conversation: structuredClone(conversation) },
-            touched: Date.now(),
-        });
-        while (conversations.size > maxSessions) {
-            const oldest = conversations.keys().next().value;
-            if (oldest === undefined)
-                break;
-            conversations.delete(oldest);
-        }
-        return { written: true, ref: key, revision };
-    };
-    return {
-        read: (sessionId, ref) => Promise.resolve(structuredClone(current(sessionId, ref))),
-        // why: A write that fails its check rejects, as any store's does, rather than throwing at the call.
-        write: (...args) => new Promise((resolve) => resolve(written(...args))),
-    };
-}
-/**
- * A store for a host that keeps nothing. The ref is the conversation sealed
- * with the host's key and bound to the session: the browser carries it and
- * cannot read or change it, and it opens in no other session.
- *
- * It cannot tell an older seal from the newest, so an older seal opens: like a
- * rewind, it returns a conversation the host wrote. Its revision is the seal.
- */
-export function createSealedConversationStore(options) {
-    const sealKey = options.keys[options.keyVersion];
-    if (sealKey === undefined) {
-        throw new TheoremError('config', labelText('error.config'), {
-            cause: { code: 'conversation_seal_key_missing', keyVersion: options.keyVersion },
-        });
-    }
-    return {
-        async read(sessionId, ref) {
-            const plaintext = await openSecret({ sealed: ref, keys: options.keys, binding: [sessionId] })
-                // why: A seal that does not open is a ref this session does not own; the caller refuses it.
-                .catch(() => undefined);
-            if (plaintext === undefined)
-                return undefined;
-            const conversation = storedConversation.parse(JSON.parse(plaintext));
-            return { revision: ref, conversation };
-        },
-        async write(sessionId, ref, expectedRevision, next) {
-            if (ref !== expectedRevision)
-                return { written: false };
-            const conversation = storedConversation.parse(next);
-            const sealed = await sealSecret({
-                plaintext: JSON.stringify(conversation),
-                key: sealKey,
-                binding: [sessionId],
-                keyVersion: options.keyVersion,
-            });
-            return { written: true, ref: sealed, revision: sealed };
-        },
-    };
-}

package/server/conversation.d.ts

@@ -1,193 +0,0 @@
-/**
- * One reply, run against the conversation its host stores: the history goes
- * to the model from the store, never from the browser, and what the reply
- * leaves (its transcript, its history, a paused reply) is written back.
- *
- * Every host runs replies through here: `createTheoremHandler` with the
- * kernel's `runTurn`, the studio with its own scope. Each run streams its
- * events, then one `conversation` line with the ref the store issued, then
- * the run's error when it failed.
- *
- * The conversation owns the transcript, the history, and the paused reply's
- * events. Which paused calls may run, and with what input, stays the host's
- * session store's: a call is answered there first, and its events settle it here.
- *
- * @module
- */
-import { type GateReference, type LabelOverrides, type Profile, type ProviderCheckpoint, TheoremError, type TurnEvent, type TurnHistoryMessage, type TurnInput } from '@theoremjs/agents';
-import { type ClientTurnOptions } from '@theoremjs/agents/host';
-import { type ComposerProfileInterface, streamThoughtsEnabled, type TranscriptBlock, type UserTurnDraft, type UserTurnHistoryMedia } from '@theoremjs/agents/interface';
-import type { ConversationLine, ConversationView, TheoremTurnInput } from '../client/transport.ts';
-import { type StoredConversation, type TheoremConversationStore } from './conversation-store.ts';
-/** One walked-away call: its id, and the run that settles it (`invokeTool` with the abandoned resume). */
-export type WalkedAwayCall = {
-    callId: string;
-    events: AsyncIterable<TurnEvent>;
-};
-/** A walked-away call as the session issued it: the operation names the one call, since a model reuses call ids. */
-export type IssuedWalkAway = WalkedAwayCall & GateReference;
-/** A turn's failure, as a run ends on it. */
-export type ErrorEvent = Extract<TurnEvent, {
-    type: 'error';
-}>;
-/** What a run needs from the host that runs it. */
-export type ConversationHost = {
-    sessionId: string;
-    store: TheoremConversationStore;
-    /** Whether the profile shows the model's thoughts (`streamThoughtsEnabled`). */
-    showThoughts: boolean;
-    /** An event as the host's reader may have it (`forClient`). */
-    forReader(event: TurnEvent): TurnEvent;
-    /** A failure as the host's reader reads it: the profile's wording, by `forClient`'s rule. */
-    failureText(failure: ErrorEvent): string;
-};
-/**
- * The conversation host for a profile as `forClient` shows it to `clientEvents`:
- * its thoughts as its outputs allow, its failures in its own wording.
- */
-export declare function readerConversationHost(args: {
-    sessionId: string;
-    store: TheoremConversationStore;
-    profile: {
-        outputs?: Parameters<typeof streamThoughtsEnabled>[0];
-        labels?: LabelOverrides;
-    };
-    clientEvents: ClientTurnOptions | undefined;
-}): ConversationHost;
-/** A conversation read for a request: its ref and revision, or neither for a new one. */
-export type OpenedConversation = {
-    ref: string | null;
-    revision: string | null;
-    conversation: StoredConversation;
-    /** What the guardrails decided reading a restored transcript, for the reply to stream first. */
-    events?: TurnEvent[];
-};
-/**
- * What a request opens a conversation for, checked as it opens, before the host starts any run:
- * - `read`: to draw it (`conversationView`).
- * - `message`: to post a message (`messageReply`). A reply that waits on gates must be walked
- *   away from: `abandon` names exactly the calls it waits on.
- * - `answer`: to answer `call`, one the reply waits on (`answerReply`).
- * - `rewind`: to cut it after transcript block `at`, which it must hold; -1 empties it
- *   (`rewindConversation`).
- */
-export type ConversationUse = {
-    kind: 'read';
-} | {
-    kind: 'message';
-    abandon?: readonly GateReference[];
-} | {
-    kind: 'answer';
-    call: GateReference;
-} | {
-    kind: 'rewind';
-    at: number;
-};
-/**
- * The conversation under `ref`, or a new one when the browser has none, refused when it does not
- * allow `use`.
- */
-export declare function openConversation(host: ConversationHost, ref: string | undefined, use: ConversationUse, restore?: ConversationRestore): Promise<OpenedConversation>;
-/**
- * The page's own transcript, for a conversation the host can no longer open (its key changed, or
- * its store forgot it): the message goes on from it rather than failing. The host's copy is the
- * truth while it opens; this is read only when it does not.
- */
-export type ConversationRestore = {
-    profile: Profile;
-    blocks: readonly TranscriptBlock[];
-};
-/**
- * Starts a conversation from blocks the host wrote, not ran: a chat that opens on an exchange
- * already under way. The model reads them as history on the next turn, read first by the
- * profile's guardrails at the `history` boundary, as every turn's history is. A match set to
- * `block` refuses them, and nothing is stored. Returns the new conversation's ref, its view for
- * the chat's `conversationView`, and the guardrail events for what matched.
- */
-export declare function startConversation(host: Pick<ConversationHost, 'sessionId' | 'store'>, profile: Profile, blocks: readonly TranscriptBlock[]): Promise<{
-    ref: string;
-    view: ConversationView;
-    events: TurnEvent[];
-}>;
-/** The conversation as the browser draws it. */
-export declare function conversationView(host: ConversationHost, conversation: StoredConversation): ConversationView;
-/** One model run of a reply: the kernel's turn input, the checkpoint it continues, and the generation. */
-export type ReplyTurn = {
-    input: TurnInput;
-    providerState?: ProviderCheckpoint;
-    model?: string;
-    effort?: string;
-};
-/** What a reply's model run takes from the host. */
-export type ReplyRunner = {
-    /** The reply's events for one run (`runTurn` with the host's own options). */
-    run(turn: ReplyTurn): AsyncIterable<TurnEvent>;
-    /**
-     * Compacts history the profile says is due for it after a reply
-     * (`done.compaction.needed`): the compacted history, or undefined to keep it.
-     */
-    compact(history: TurnHistoryMessage[], tokens: number, model: string | undefined): Promise<TurnHistoryMessage[] | undefined>;
-    model?: string;
-    effort?: string;
-    signal: AbortSignal;
-};
-/** A line of a reply's stream: an event, or the ref of what the store wrote. */
-export type ReplyLine = TurnEvent | ConversationLine;
-/** The person's new message, as the host checked it: its blocks, its media, and the kernel's input. */
-export type PostedMessage = {
-    draft: UserTurnDraft;
-    /** The message's blocks (`prepareUserTurn`), with their media inline. */
-    blocks: TranscriptBlock[];
-    media: UserTurnHistoryMedia;
-    /** The kernel input without history: the message's text as the transcript shows it, its media, slots, and context. */
-    input: TurnInput;
-};
-/**
- * The person's message as the profile accepts it: refused when its files break the profile's
- * limits. `server` is the host's own context for the run (the handler's `context` option).
- */
-export declare function postedMessage(iface: ComposerProfileInterface, input: TheoremTurnInput, server?: unknown): PostedMessage;
-/**
- * The person sends a message. A reply that waits on gates is walked away
- * from first: each call settles cancelled and the paused reply commits; then
- * the message posts and its reply runs.
- */
-export declare function messageReply(args: {
-    host: ConversationHost;
-    opened: OpenedConversation;
-    message: PostedMessage;
-    /** The paused reply's calls, each with the run that settles it: exactly the calls it waits on. */
-    walkAway?: readonly IssuedWalkAway[];
-    runner: ReplyRunner;
-}): AsyncGenerator<ReplyLine>;
-/**
- * The person answers one call the reply waits on. `settling` streams the
- * call's events; once no call waits, the reply goes on in the same stream.
- */
-export declare function answerReply(args: {
-    host: ConversationHost;
-    opened: OpenedConversation;
-    /** The call answered, as the session issued it. */
-    call: GateReference;
-    settling: AsyncIterable<TurnEvent>;
-    runner: ReplyRunner;
-}): AsyncGenerator<ReplyLine>;
-/**
- * The conversation cut after transcript block `at` (-1 empties it): the
- * history is rebuilt from what is kept, and the model's checkpoint and meters
- * start over. A paused reply is walked away from first, and commits before the cut.
- */
-export declare function rewindConversation(args: {
-    host: ConversationHost;
-    opened: OpenedConversation;
-    at: number;
-    walkAway?: readonly IssuedWalkAway[];
-}): Promise<OpenedConversation>;
-/** A paused call's operation: every call a session issued carries one. */
-export declare function requiredOperationId(call: {
-    operationId?: string;
-}): string;
-/** The calls a paused reply waits on: the ones a message or a rewind walks away from. */
-export declare function waitingCalls(conversation: StoredConversation): GateReference[];
-/** Refuses what only a kept conversation answers, for a profile that keeps none. */
-export declare function statelessRefusal(what: string): TheoremError;