@teaflask/assistant 0.0.0 → 0.6.0

package/dist/core/consumed-interrupts.js

@@ -0,0 +1,64 @@
+import { INTERRUPT_ANSWER_CONSUMED_EVENT_NAME, } from "../contract/events.js";
+export function interruptAnswerConsumedPayloadOf(value) {
+    if (typeof value !== "object" || value === null) {
+        return null;
+    }
+    const payload = value;
+    if (typeof payload.interrupt_id !== "string" ||
+        typeof payload.round !== "number") {
+        return null;
+    }
+    return { interruptId: payload.interrupt_id, round: payload.round };
+}
+export function consumedInterruptRecorder(onConsumed) {
+    let currentRunId = null;
+    return {
+        onRunStartedEvent({ event }) {
+            currentRunId = event.runId;
+        },
+        onCustomEvent({ event }) {
+            if (event.name !== INTERRUPT_ANSWER_CONSUMED_EVENT_NAME) {
+                return;
+            }
+            const consumed = interruptAnswerConsumedPayloadOf(event.value);
+            if (consumed === null || currentRunId === null) {
+                return;
+            }
+            onConsumed(currentRunId, consumed);
+        },
+    };
+}
+const _NO_CONSUMED_IDS = new Set();
+export class ConsumedInterruptFold {
+    byRun = new Map();
+    note(runId, interruptId, round) {
+        let byRound = this.byRun.get(runId);
+        if (byRound === undefined) {
+            byRound = new Map();
+            this.byRun.set(runId, byRound);
+            while (this.byRun.size > 8) {
+                const oldest = this.byRun.keys().next().value;
+                if (oldest === undefined) {
+                    break;
+                }
+                this.byRun.delete(oldest);
+            }
+        }
+        let consumed = byRound.get(round);
+        if (consumed === undefined) {
+            consumed = new Set();
+            byRound.set(round, consumed);
+        }
+        if (consumed.has(interruptId)) {
+            return false;
+        }
+        consumed.add(interruptId);
+        return true;
+    }
+    idsOf(runId, awaitingRound) {
+        if (runId == null || awaitingRound == null) {
+            return _NO_CONSUMED_IDS;
+        }
+        return this.byRun.get(runId)?.get(awaitingRound) ?? _NO_CONSUMED_IDS;
+    }
+}

package/dist/core/conversation-adoption.d.ts

@@ -0,0 +1,13 @@
+import type { AssistantThreadDetailResponse, ServingAssistantThread, ServingAssistantTurn } from "../contract/threads.js";
+import type { ComposerModelPick } from "./conversation-contract.js";
+import type { AssistantConversationStore } from "./conversation-store.js";
+export declare function resumeStoredThreadFromStore(store: AssistantConversationStore): void;
+export declare function openThreadFromStore(store: AssistantConversationStore, thread: ServingAssistantThread): void;
+export declare function startNewConversationFromStore(store: AssistantConversationStore): void;
+export declare function adoptRefreshedDetail(store: AssistantConversationStore, detail: AssistantThreadDetailResponse): void;
+export declare function enterConversationFromSend(store: AssistantConversationStore, thread: ServingAssistantThread, turn: ServingAssistantTurn, sentPick: ComposerModelPick | null): void;
+export declare function invalidateInFlightResume(store: AssistantConversationStore): void;
+export declare function refreshThreads(store: AssistantConversationStore): Promise<void>;
+export declare function loadHistoryOnceExpected(store: AssistantConversationStore): void;
+export declare function historyExpected(store: AssistantConversationStore): boolean;
+export declare function sameModelPick(a: ComposerModelPick | null, b: ComposerModelPick | null): boolean;

package/dist/core/conversation-adoption.js

@@ -0,0 +1,325 @@
+import { clearStoredThread, readStoredThread, readStoredThreadFor, writeStoredThread, } from "../persistence/stored-thread.js";
+import { getAssistantThread, listAssistantThreads, } from "../transport/serving-api.js";
+import { ServingApiError } from "../transport/serving-error.js";
+import { StreamResumeStore } from "../transport/stream-resume.js";
+import { ApprovalInbox, SERVING_APPROVAL_CAPABILITIES, } from "./approval-inbox.js";
+import { resetComposerInput } from "./composer-input-state.js";
+import { publishStore } from "./conversation-publish.js";
+import { noteNewestTurn, publishApprovalCards, reconcileApprovals, } from "./epoch-sync.js";
+import { userSentenceFor } from "./error-copy.js";
+import { backfilledTurnsOf, TURNS_WINDOW } from "./turns-backfill.js";
+import { failureSentenceOf } from "./turn-failure-copy.js";
+import { UserTurnLedger, userMessageIdFor } from "./user-turn-ledger.js";
+const HISTORY_WINDOW = 200;
+export function resumeStoredThreadFromStore(store) {
+    const stored = readStoredThreadFor(store.deps.publishableKey, store.deps.userId);
+    if (stored === null) {
+        if (store.deps.userId !== undefined &&
+            readStoredThread(store.deps.publishableKey) !== null) {
+            clearStoredThread(store.deps.publishableKey);
+        }
+        if (store._active !== null) {
+            _abandonConversation(store);
+        }
+        return;
+    }
+    const request = store._resumeRequest + 1;
+    store._resumeRequest = request;
+    if (store._active === null) {
+        store._threadOpening = true;
+        publishStore(store);
+    }
+    getAssistantThread(store.deps.session, stored.threadId)
+        .then((detail) => {
+        if (store._resumeRequest === request) {
+            _adoptThreadDetail(store, detail);
+        }
+    })
+        .catch((error) => {
+        if (store._resumeRequest !== request) {
+            return;
+        }
+        store._threadOpening = false;
+        publishStore(store);
+        if (_threadIsGone(error)) {
+            clearStoredThread(store.deps.publishableKey);
+            if (store._active !== null) {
+                _abandonConversation(store);
+            }
+            return;
+        }
+        if (error instanceof Error) {
+            store.deps.reportError(error);
+        }
+    });
+}
+export function openThreadFromStore(store, thread) {
+    invalidateInFlightResume(store);
+    store._sendError = null;
+    store._streamInterrupted = false;
+    store._stopping = false;
+    store._pendingEcho = null;
+    store._threadOpening = true;
+    publishStore(store);
+    const request = store._resumeRequest;
+    getAssistantThread(store.deps.session, thread.id)
+        .then((detail) => {
+        if (store._resumeRequest !== request) {
+            return;
+        }
+        _adoptThreadDetail(store, detail);
+        writeStoredThread(store.deps.publishableKey, _storedThreadOf(store, detail.thread.id));
+    })
+        .catch((error) => {
+        if (store._resumeRequest !== request) {
+            return;
+        }
+        store._threadOpening = false;
+        store._sendError = userSentenceFor(error);
+        if (_threadIsGone(error)) {
+            store._threads = store._threads.filter((t) => t.id !== thread.id);
+        }
+        publishStore(store);
+        if (error instanceof Error) {
+            store.deps.reportError(error);
+        }
+    });
+}
+export function startNewConversationFromStore(store) {
+    _abandonConversation(store);
+    clearStoredThread(store.deps.publishableKey);
+}
+function _adoptThreadDetail(store, detail) {
+    const ask = ++store._adoptionAsk;
+    if (detail.turns.length < TURNS_WINDOW) {
+        _finishAdoption(store, detail);
+        return;
+    }
+    void backfilledTurnsOf(detail.turns, (cursor) => getAssistantThread(store.deps.session, detail.thread.id, cursor), { isStale: () => store._adoptionAsk !== ask }).then((turns) => {
+        if (turns !== null) {
+            _finishAdoption(store, { thread: detail.thread, turns });
+        }
+    });
+}
+function _finishAdoption(store, detail) {
+    const active = store._active;
+    const continuing = active !== null && active.thread.id === detail.thread.id;
+    const ledger = continuing ? active.ledger : new UserTurnLedger();
+    const resume = continuing ? active.resume : new StreamResumeStore();
+    const approvalInbox = continuing
+        ? active.approvalInbox
+        : new ApprovalInbox(SERVING_APPROVAL_CAPABILITIES);
+    ledger.merge(detail.turns);
+    store._active = {
+        thread: detail.thread,
+        ledger,
+        resume,
+        approvalInbox,
+        coworkerRequestTurns: detail.turns,
+    };
+    if (!continuing) {
+        store.questionDrafts.clearAll();
+    }
+    _adoptWireModelPick(store, detail.thread, { evenWhenDirty: !continuing });
+    if (!continuing) {
+        resetComposerInput(store, detail.thread.id);
+    }
+    store._threadOpening = false;
+    noteNewestTurn(store, detail.turns.at(-1) ?? null, !continuing);
+    store._awaitingTurn = _newestAnswerableTurnOf(detail.turns);
+    reconcileApprovals(store, detail.turns);
+    adoptCoworkerRequests(store, detail.turns);
+    store._turnFailure = failureSentenceOf(detail.turns);
+    store._streamInterrupted = false;
+    if (!_someTurnIsLive(detail.turns)) {
+        store._stopping = false;
+    }
+    publishStore(store);
+}
+function adoptCoworkerRequests(store, turns) {
+    const active = store._active;
+    if (active !== null) {
+        active.coworkerRequestTurns = turns;
+    }
+    store._epoch?.withExecutionInbox((inbox) => {
+        const adopted = inbox.adoptCoworkerRequests(turns);
+        const reconciled = inbox.reconcileWithTurns(turns);
+        return adopted || reconciled;
+    });
+    if (active?.approvalInbox.adoptCoworkerApprovals(turns) === true) {
+        publishApprovalCards(store, active.approvalInbox.cards());
+    }
+}
+export function adoptRefreshedDetail(store, detail) {
+    const active = store._active;
+    if (active?.thread.id !== detail.thread.id) {
+        return;
+    }
+    active.ledger.merge(detail.turns);
+    if (_sameWireRecord(active.thread, detail.thread)) {
+        store._active = active;
+    }
+    else {
+        store._active = {
+            thread: detail.thread,
+            ledger: active.ledger,
+            resume: active.resume,
+            approvalInbox: active.approvalInbox,
+            coworkerRequestTurns: active.coworkerRequestTurns,
+        };
+    }
+    _adoptWireModelPick(store, detail.thread, { evenWhenDirty: false });
+    noteNewestTurn(store, detail.turns.at(-1) ?? null);
+    store._awaitingTurn = _newestAnswerableTurnOf(detail.turns);
+    reconcileApprovals(store, detail.turns);
+    adoptCoworkerRequests(store, detail.turns);
+    store._turnFailure = failureSentenceOf(detail.turns);
+    if (!_someTurnIsLive(detail.turns)) {
+        store._stopping = false;
+    }
+    publishStore(store);
+}
+function _adoptWireModelPick(store, thread, { evenWhenDirty }) {
+    if (store._modelPickDirty && !evenWhenDirty) {
+        return;
+    }
+    const pick = thread.model_pick ?? null;
+    store._modelPick =
+        pick === null
+            ? null
+            : { modelId: pick.model_id ?? null, effort: pick.effort ?? null };
+    store._modelPickDirty = false;
+}
+export function enterConversationFromSend(store, thread, turn, sentPick) {
+    if (store._disposed) {
+        return;
+    }
+    invalidateInFlightResume(store);
+    const active = store._active;
+    const continuing = active !== null && active.thread.id === thread.id;
+    const ledger = continuing ? active.ledger : new UserTurnLedger();
+    const resume = continuing ? active.resume : new StreamResumeStore();
+    const approvalInbox = continuing
+        ? active.approvalInbox
+        : new ApprovalInbox(SERVING_APPROVAL_CAPABILITIES);
+    if (continuing) {
+        approvalInbox.markPauseStale();
+        approvalInbox.markCoworkerCardsStale();
+        store._epoch?.withExecutionInbox((inbox) => inbox.markCoworkerRequestsStale());
+    }
+    ledger.record(turn);
+    store._active = {
+        thread,
+        ledger,
+        resume,
+        approvalInbox,
+        coworkerRequestTurns: [],
+    };
+    if (sameModelPick(store._modelPick, sentPick)) {
+        _adoptWireModelPick(store, thread, { evenWhenDirty: true });
+    }
+    noteNewestTurn(store, turn, !continuing);
+    store._composerInput.set({
+        ...store._composerInput.get(),
+        scope: `t:${thread.id}`,
+    });
+    writeStoredThread(store.deps.publishableKey, _storedThreadOf(store, thread.id));
+    store._pendingEcho = {
+        messageId: userMessageIdFor(turn.id),
+        text: turn.user_message,
+        attachments: turn.attachments ?? [],
+    };
+    store._reconnectNonce += 1;
+    publishStore(store);
+    void refreshThreads(store);
+}
+function _abandonConversation(store) {
+    invalidateInFlightResume(store);
+    store._sendError = null;
+    store._turnFailure = null;
+    store._streamInterrupted = false;
+    store._stopping = false;
+    store._threadOpening = false;
+    store._pendingEcho = null;
+    store._active = null;
+    store._newestTurn = null;
+    store._awaitingTurn = null;
+    store._lastResult = null;
+    store._modelPick = null;
+    store._modelPickDirty = false;
+    resetComposerInput(store, null);
+    store.questionDrafts.clearAll();
+    publishStore(store);
+}
+export function invalidateInFlightResume(store) {
+    store._resumeRequest += 1;
+    store._threadOpening = false;
+    store._adoptionAsk += 1;
+}
+export async function refreshThreads(store) {
+    if (!_historyRefreshable(store)) {
+        return;
+    }
+    try {
+        const threads = await listAssistantThreads(store.deps.session, {
+            limit: HISTORY_WINDOW,
+        });
+        if (store._disposed) {
+            return;
+        }
+        store._threads = threads;
+        publishStore(store);
+    }
+    catch {
+    }
+}
+export function loadHistoryOnceExpected(store) {
+    if (!historyExpected(store) || store._historyLoadRequested) {
+        return;
+    }
+    store._historyLoadRequested = true;
+    listAssistantThreads(store.deps.session, { limit: HISTORY_WINDOW })
+        .then((history) => {
+        if (!store._disposed) {
+            store._threads = history;
+            publishStore(store);
+        }
+    })
+        .catch(() => {
+    });
+}
+function _historyRefreshable(store) {
+    return store._tier === "identified" && !store._disposed;
+}
+export function historyExpected(store) {
+    return store.deps.userId !== undefined || store._tier === "identified";
+}
+function _threadIsGone(error) {
+    return error instanceof ServingApiError && error.status === 404;
+}
+function _storedThreadOf(store, threadId) {
+    return store._tier === "identified"
+        ? { threadId, identified: true, userId: store.deps.userId }
+        : { threadId, identified: false };
+}
+function _someTurnIsLive(turns) {
+    return turns.some((turn) => turn.status === "working" || turn.status === "awaiting_input");
+}
+function _newestAnswerableTurnOf(turns) {
+    for (let index = turns.length - 1; index >= 0; index -= 1) {
+        const turn = turns[index];
+        if (turn.status === "awaiting_input" || turn.status === "parked") {
+            return turn;
+        }
+    }
+    return null;
+}
+export function sameModelPick(a, b) {
+    if (a === null || b === null) {
+        return a === b;
+    }
+    return a.modelId === b.modelId && a.effort === b.effort;
+}
+function _sameWireRecord(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}

package/dist/core/conversation-contract.d.ts

@@ -0,0 +1,87 @@
+import type { ServedThinkingEffort } from "../contract/assistant-config.js";
+import type { AssistantTelemetryEvent } from "../contract/telemetry.js";
+import type { ServingAssistantThread, ServingAssistantTurn, TurnAttachment } from "../contract/threads.js";
+import type { ServingReplayStreamAgent } from "../transport/replay-stream-agent.js";
+import type { ServingApiError } from "../transport/serving-error.js";
+import type { StreamResumeStore } from "../transport/stream-resume.js";
+import type { TokenSession } from "../transport/token-session.js";
+import type { ApprovalInbox } from "./approval-inbox.js";
+import type { AttachmentDraft } from "./composer-policy.js";
+import type { ExecuteActionIntent, HostNavigate } from "./execution-handlers.js";
+import type { ReadonlyCell } from "./observable-cell.js";
+import type { PendingDecisionGap } from "./pending-decision-gap.js";
+import type { UserTurnLedger } from "./user-turn-ledger.js";
+export interface ActiveConversation {
+    thread: ServingAssistantThread;
+    ledger: UserTurnLedger;
+    resume: StreamResumeStore;
+    approvalInbox: ApprovalInbox;
+    coworkerRequestTurns: readonly ServingAssistantTurn[];
+}
+export interface ComposerContract {
+    busy: boolean;
+    pendingSend: boolean;
+    sendMessage: (message: string, attachmentIds?: string[], optimisticAttachments?: TurnAttachment[]) => Promise<boolean>;
+    pendingEcho: {
+        messageId: string;
+        text: string;
+        attachments: TurnAttachment[];
+    } | null;
+    composerRefocusPending: boolean;
+    markComposerRefocusHandled: () => void;
+    stopping: boolean;
+    stopTurn: () => Promise<void>;
+    modelPick: ComposerModelPick | null;
+    setModelPick: (pick: ComposerModelPick) => void;
+    composerInput: ReadonlyCell<ComposerInput>;
+    setDraft: (next: string | ((current: string) => string)) => void;
+    setAttachments: (next: readonly AttachmentDraft[] | ((current: readonly AttachmentDraft[]) => readonly AttachmentDraft[])) => void;
+    noteComposerFocus: (owner: string | null) => void;
+    takeComposerCaretReturn: (surface: string) => boolean;
+}
+export interface ComposerInput {
+    scope: string;
+    draft: string;
+    attachments: readonly AttachmentDraft[];
+}
+export interface ComposerModelPick {
+    modelId: string | null;
+    effort: ServedThinkingEffort | null;
+}
+export type { AttachmentDraft } from "./composer-policy.js";
+export type { ApprovalDecisionInput } from "./approval-inbox.js";
+export interface ConversationSnapshot {
+    active: ActiveConversation | null;
+    threads: ServingAssistantThread[];
+    historyExpected: boolean;
+    threadOpening: boolean;
+    reconnectNonce: number;
+    sendError: string | null;
+    turnFailure: string | null;
+    showInterruptionBanner: boolean;
+    pendingDecisionGap: PendingDecisionGap | null;
+}
+export interface HostCapabilities {
+    navigate: HostNavigate | null;
+    executeActionIntent: ExecuteActionIntent | null;
+}
+export interface ConversationStoreDeps {
+    session: TokenSession;
+    publishableKey: string;
+    userId?: string;
+    hostCapabilitiesOf: () => HostCapabilities;
+    reportError: (error: Error) => void;
+    onTelemetry: (event: AssistantTelemetryEvent) => void;
+    onGateRefusal: (error: ServingApiError) => void;
+    onTurnSettled: () => void;
+}
+export interface ConnectionSnapshot {
+    epochId: number;
+    agent: ServingReplayStreamAgent;
+    threadId: string;
+    streamThreadId: string;
+}
+export interface MintedDownloadUrl {
+    url: string;
+    expiresAtMs: number;
+}

package/dist/core/conversation-contract.js

@@ -0,0 +1 @@
+export {};

package/dist/core/conversation-publish.d.ts

@@ -0,0 +1,8 @@
+import type { ComposerContract, ConversationSnapshot } from "./conversation-contract.js";
+import type { AssistantConversationStore } from "./conversation-store.js";
+export declare function publishStore(store: AssistantConversationStore): void;
+export declare function scheduleConnectionSync(store: AssistantConversationStore): void;
+export declare function conversationSnapshotOf(store: AssistantConversationStore): ConversationSnapshot;
+export declare function noteInterruptAnswerConsumed(store: AssistantConversationStore, runId: string, interruptId: string, round: number): void;
+export declare function composerSnapshotOf(store: AssistantConversationStore): ComposerContract;
+export declare function busyOf(store: AssistantConversationStore): boolean;

package/dist/core/conversation-publish.js

@@ -0,0 +1,117 @@
+import { syncConnection } from "./connection-driver.js";
+import { historyExpected, sameModelPick } from "./conversation-adoption.js";
+import { publishActivity, syncEpoch, theAnswerablePause, } from "./epoch-sync.js";
+import { syncIdleRecheck } from "./idle-recheck.js";
+import { pendingDecisionGapOf } from "./pending-decision-gap.js";
+import { bannerFailureSentenceOf } from "./turn-failure-copy.js";
+export function publishStore(store) {
+    store._inPublish = true;
+    try {
+        syncEpoch(store);
+        _updatePendingDecisionGap(store);
+        _publishTurnMeta(store);
+        const conversation = conversationSnapshotOf(store);
+        if (!_sameConversationSnapshot(conversation, store._conversationCell.get())) {
+            store._conversationCell.set(conversation);
+        }
+        const composer = composerSnapshotOf(store);
+        if (!_sameComposerSnapshot(composer, store._composerCell.get())) {
+            store._composerCell.set(composer);
+        }
+        publishActivity(store);
+        scheduleConnectionSync(store);
+        syncIdleRecheck(store);
+    }
+    finally {
+        store._inPublish = false;
+    }
+}
+export function scheduleConnectionSync(store) {
+    if (store._connectionSyncQueued || store._disposed) {
+        return;
+    }
+    store._connectionSyncQueued = true;
+    queueMicrotask(() => {
+        store._connectionSyncQueued = false;
+        syncConnection(store);
+    });
+}
+export function conversationSnapshotOf(store) {
+    return {
+        active: store._active,
+        threads: store._threads,
+        historyExpected: historyExpected(store),
+        threadOpening: store._threadOpening,
+        reconnectNonce: store._reconnectNonce,
+        sendError: store._sendError,
+        turnFailure: bannerFailureSentenceOf(store._turnFailure, store._active?.resume.turnFailedAnchors),
+        showInterruptionBanner: store._streamInterrupted && busyOf(store) && !store._stopping,
+        pendingDecisionGap: store._pendingDecisionGap,
+    };
+}
+function _updatePendingDecisionGap(store) {
+    if (store._disposed) {
+        return;
+    }
+    const pause = theAnswerablePause(store) ?? store._newestTurn;
+    store._gapGate.judge(pendingDecisionGapOf(pause, store._active?.approvalInbox.cards() ?? [], store._elicitationsCell.get(), store._epoch?.executionInbox.entries() ?? [], store._consumedInterrupts.idsOf(pause?.run_id, pause?.awaiting_round)));
+}
+export function noteInterruptAnswerConsumed(store, runId, interruptId, round) {
+    if (store._consumedInterrupts.note(runId, interruptId, round)) {
+        publishStore(store);
+    }
+}
+export function composerSnapshotOf(store) {
+    return {
+        busy: busyOf(store),
+        pendingSend: store._pendingSend,
+        sendMessage: store.sendMessage,
+        pendingEcho: store._pendingEcho,
+        composerRefocusPending: store._composerRefocusPending,
+        markComposerRefocusHandled: store.markComposerRefocusHandled,
+        stopping: store._stopping,
+        stopTurn: store.stopTurn,
+        modelPick: store._modelPick,
+        setModelPick: store.setModelPick,
+        composerInput: store._composerInput,
+        setDraft: store.setComposerDraft,
+        setAttachments: store.setComposerAttachments,
+        noteComposerFocus: store.noteComposerFocus,
+        takeComposerCaretReturn: store.takeComposerCaretReturn,
+    };
+}
+export function busyOf(store) {
+    return (((store._active?.thread.busy ?? false) &&
+        store._newestTurn?.status !== "parked") ||
+        store._pendingSend);
+}
+function _publishTurnMeta(store) {
+    const ledger = store._active?.ledger ?? null;
+    const version = ledger?.version ?? -1;
+    if (ledger === store._publishedMetaLedger &&
+        version === store._publishedMetaVersion) {
+        return;
+    }
+    store._publishedMetaLedger = ledger;
+    store._publishedMetaVersion = version;
+    store._turnMetaCell.set(ledger !== null ? ledger.metaByMessageId() : new Map());
+}
+function _sameConversationSnapshot(a, b) {
+    return (a.active === b.active &&
+        a.threads === b.threads &&
+        a.historyExpected === b.historyExpected &&
+        a.threadOpening === b.threadOpening &&
+        a.reconnectNonce === b.reconnectNonce &&
+        a.sendError === b.sendError &&
+        a.turnFailure === b.turnFailure &&
+        a.showInterruptionBanner === b.showInterruptionBanner &&
+        a.pendingDecisionGap === b.pendingDecisionGap);
+}
+function _sameComposerSnapshot(a, b) {
+    return (a.busy === b.busy &&
+        a.pendingSend === b.pendingSend &&
+        a.pendingEcho === b.pendingEcho &&
+        a.composerRefocusPending === b.composerRefocusPending &&
+        a.stopping === b.stopping &&
+        sameModelPick(a.modelPick, b.modelPick));
+}

package/dist/core/conversation-refresh.d.ts

@@ -0,0 +1,4 @@
+import type { AssistantConversationStore } from "./conversation-store.js";
+export declare function refreshConversationFromStore(store: AssistantConversationStore): Promise<void>;
+export declare function noteDispatchSettledFromStore(store: AssistantConversationStore): void;
+export declare function settlesFor(delayMs: number): Promise<void>;