@teaflask/assistant 0.0.0 → 0.6.0

package/dist/components/use-roster-disclosure.js

@@ -0,0 +1,114 @@
+"use client";
+import { useEffect, useId, useRef, useState } from "react";
+import { focusIfRestorable } from "./subagent-delegation-surface.js";
+import { useSubagentDrillIn } from "./subagent-drill-in.js";
+export function useRosterDisclosure() {
+    const [open, setOpen] = useState(false);
+    const rosterId = useId();
+    const triggerRef = useRef(null);
+    const wrapperRef = useRef(null);
+    const drillIn = useSubagentDrillIn();
+    const openRoster = () => {
+        drillIn?.dismiss();
+        setOpen(true);
+    };
+    const muteFocusOpenRef = useRef(false);
+    return {
+        open,
+        rosterId,
+        triggerRef,
+        wrapperRef,
+        onWrapperPointerEnter: (event) => {
+            if (event.pointerType !== "touch") {
+                openRoster();
+            }
+        },
+        onWrapperPointerLeave: (event) => {
+            if (event.pointerType !== "touch") {
+                muteFocusOpenRef.current = false;
+                const wrapper = wrapperRef.current;
+                const root = wrapper?.getRootNode();
+                const active = root instanceof Document || root instanceof ShadowRoot
+                    ? root.activeElement
+                    : null;
+                if (wrapper !== null &&
+                    active instanceof HTMLElement &&
+                    active.tabIndex >= 0 &&
+                    active !== triggerRef.current &&
+                    wrapper.contains(active)) {
+                    return;
+                }
+                setOpen(false);
+            }
+        },
+        onWrapperBlur: (event) => {
+            const next = event.relatedTarget;
+            if (wrapperRef.current !== null &&
+                (!(next instanceof Node) || !wrapperRef.current.contains(next))) {
+                setOpen(false);
+            }
+        },
+        onTriggerPointerDown: (event) => {
+            if (event.button === 0) {
+                muteFocusOpenRef.current = true;
+            }
+        },
+        onTriggerPointerCancel: () => {
+            muteFocusOpenRef.current = false;
+        },
+        onTriggerFocus: () => {
+            if (!muteFocusOpenRef.current) {
+                openRoster();
+            }
+            muteFocusOpenRef.current = false;
+        },
+        onTriggerClick: () => {
+            muteFocusOpenRef.current = false;
+            if (open) {
+                setOpen(false);
+            }
+            else {
+                openRoster();
+            }
+        },
+        onTriggerKeyDown: (event) => {
+            if (!open || event.key !== "Escape") {
+                return;
+            }
+            event.preventDefault();
+            event.stopPropagation();
+            setOpen(false);
+        },
+        close: () => {
+            setOpen(false);
+        },
+        refocusTrigger: () => {
+            muteFocusOpenRef.current = true;
+            focusIfRestorable(triggerRef.current);
+        },
+    };
+}
+export function useFloatingDismiss(floatingRef, triggerRef, onClose) {
+    useEffect(() => {
+        const floating = floatingRef.current;
+        if (floating === null) {
+            return;
+        }
+        const closeUnlessInside = (event) => {
+            const path = event.composedPath();
+            if (path.includes(floating)) {
+                return;
+            }
+            const trigger = triggerRef.current;
+            if (trigger !== null && path.includes(trigger)) {
+                return;
+            }
+            onClose();
+        };
+        const doc = floating.ownerDocument;
+        doc.addEventListener("pointerdown", closeUnlessInside);
+        return () => {
+            doc.removeEventListener("pointerdown", closeUnlessInside);
+        };
+    }, [floatingRef, onClose, triggerRef]);
+}

package/dist/components/use-roster-preview.d.ts

@@ -0,0 +1,24 @@
+import { type RefObject } from "react";
+interface PreviewChoreography {
+    previewKey: string | null;
+    setPreviewKey: (key: string | null) => void;
+    previewRef: RefObject<HTMLDivElement | null>;
+    previewOpenerRef: RefObject<HTMLButtonElement | null>;
+    mutePreviewFocusOpenRef: RefObject<boolean>;
+    onPreviewChange: (key: string, open: boolean) => void;
+    onPreviewOpener: (opener: HTMLButtonElement) => void;
+    onPreviewFocus: (key: string, opener: HTMLButtonElement) => void;
+    focusPreview: () => void;
+}
+export declare function usePreviewChoreography(): PreviewChoreography;
+export declare function usePreviewEscape(wires: {
+    floatingRef: RefObject<HTMLDivElement | null>;
+    previewRef: RefObject<HTMLDivElement | null>;
+    previewOpenerRef: RefObject<HTMLButtonElement | null>;
+    mutePreviewFocusOpenRef: RefObject<boolean>;
+    previewKey: string | null;
+    setPreviewKey: (key: string | null) => void;
+    onClose: () => void;
+    refocusTrigger: () => void;
+}): void;
+export {};

package/dist/components/use-roster-preview.js

@@ -0,0 +1,82 @@
+"use client";
+import { useEffect, useRef, useState } from "react";
+export function usePreviewChoreography() {
+    const previewRef = useRef(null);
+    const previewOpenerRef = useRef(null);
+    const mutePreviewFocusOpenRef = useRef(false);
+    const [previewKey, setPreviewKey] = useState(null);
+    return {
+        previewKey,
+        setPreviewKey,
+        previewRef,
+        previewOpenerRef,
+        mutePreviewFocusOpenRef,
+        onPreviewChange: (key, nextOpen) => {
+            setPreviewKey(nextOpen ? key : null);
+        },
+        onPreviewOpener: (opener) => {
+            previewOpenerRef.current = opener;
+        },
+        onPreviewFocus: (key, opener) => {
+            if (mutePreviewFocusOpenRef.current) {
+                mutePreviewFocusOpenRef.current = false;
+                return;
+            }
+            previewOpenerRef.current = opener;
+            setPreviewKey(key);
+        },
+        focusPreview: () => {
+            previewRef.current?.focus();
+        },
+    };
+}
+export function usePreviewEscape(wires) {
+    const { floatingRef, previewRef, previewOpenerRef, mutePreviewFocusOpenRef, previewKey, setPreviewKey, onClose, refocusTrigger, } = wires;
+    useEffect(() => {
+        const floating = floatingRef.current;
+        if (floating === null) {
+            return;
+        }
+        const preview = previewRef.current;
+        const closeOnEscape = (event) => {
+            if (event.key !== "Escape") {
+                return;
+            }
+            event.preventDefault();
+            event.stopPropagation();
+            if (previewKey !== null) {
+                setPreviewKey(null);
+                const opener = previewOpenerRef.current;
+                const root = opener?.getRootNode();
+                const active = root instanceof Document || root instanceof ShadowRoot
+                    ? root.activeElement
+                    : null;
+                if (opener !== null && opener !== active) {
+                    mutePreviewFocusOpenRef.current = true;
+                    opener.focus();
+                }
+                else {
+                    mutePreviewFocusOpenRef.current = false;
+                }
+                return;
+            }
+            onClose();
+            refocusTrigger();
+        };
+        floating.addEventListener("keydown", closeOnEscape);
+        preview?.addEventListener("keydown", closeOnEscape);
+        return () => {
+            floating.removeEventListener("keydown", closeOnEscape);
+            preview?.removeEventListener("keydown", closeOnEscape);
+        };
+    }, [
+        floatingRef,
+        previewRef,
+        previewOpenerRef,
+        mutePreviewFocusOpenRef,
+        onClose,
+        previewKey,
+        setPreviewKey,
+        refocusTrigger,
+    ]);
+}

package/dist/components/use-store-cell.d.ts

@@ -0,0 +1,2 @@
+import type { ReadonlyCell } from "../core/observable-cell.js";
+export declare function useCell<T>(cell: ReadonlyCell<T>): T;

package/dist/components/use-store-cell.js

@@ -0,0 +1,5 @@
+"use client";
+import { useSyncExternalStore } from "react";
+export function useCell(cell) {
+    return useSyncExternalStore(cell.subscribe, cell.get, cell.get);
+}

package/dist/components/use-thread-dispatches.d.ts

@@ -0,0 +1,8 @@
+import { type ThreadDispatch } from "../contract/dispatches.js";
+import type { TranscriptRow } from "../core/transcript-rows.js";
+import type { TokenSession } from "../transport/token-session.js";
+export declare function useThreadDispatches(session: TokenSession, threadId: string | null, rows: readonly TranscriptRow[], onDispatchSettled?: () => void, onDispatchPaused?: () => void): ReadonlyMap<number, ThreadDispatch>;
+export declare function useChildDispatch(session: TokenSession, threadId: string | null, childSessionId: string): {
+    dispatch: ThreadDispatch | undefined;
+    refreshLedger: () => Promise<ThreadDispatch | undefined>;
+};

package/dist/components/use-thread-dispatches.js

@@ -0,0 +1,400 @@
+"use client";
+import { useCallback, useEffect, useMemo } from "react";
+import { dispatchIsPaused, dispatchIsRunning, } from "../contract/dispatches.js";
+import { ObservableCell } from "../core/observable-cell.js";
+import { dispatchReceiptOf } from "../core/subagent-rows.js";
+import { listThreadDispatches } from "../transport/serving-api.js";
+import { resolvedSubagentEntryOf } from "./subagent-group-row.js";
+import { useCell } from "./use-store-cell.js";
+const POLL_INTERVAL_MS = 10_000;
+const MAX_CONSECUTIVE_READ_FAILURES = 3;
+const READ_BOUND_MS = 2 * POLL_INTERVAL_MS;
+const EMPTY_LEDGER = new Map();
+const RESUME_SUBAGENT_TOOL_NAME = "resume_subagent";
+function aResumeAwaitsLedgerTruth(rows, ledger) {
+    return rows.some((row) => {
+        if (row.kind !== "tool-call" ||
+            row.toolName !== RESUME_SUBAGENT_TOOL_NAME) {
+            return false;
+        }
+        const receipt = dispatchReceiptOf(row.result);
+        if (receipt === null || receipt.outcome === "already_settled") {
+            return false;
+        }
+        const dispatched = ledger.get(receipt.ordinal);
+        return dispatched === undefined || dispatchIsRunning(dispatched);
+    });
+}
+function newestRowForSession(map, childSessionId) {
+    let newest;
+    for (const dispatch of map.values()) {
+        if (dispatch.child_session_id !== childSessionId) {
+            continue;
+        }
+        if (newest === undefined || dispatch.ordinal > newest.ordinal) {
+            newest = dispatch;
+        }
+    }
+    return newest;
+}
+function anySubagentStillRunning(rows, ledger) {
+    return rows.some((row) => row.kind === "subagent-group" &&
+        row.entries.some((entry) => entry.receipt != null &&
+            resolvedSubagentEntryOf(entry, ledger).running));
+}
+class ThreadDispatchLedger {
+    session;
+    cell = new ObservableCell(null);
+    demands = new Map();
+    timer = null;
+    timerThreadId = null;
+    busy = false;
+    readThreadId = null;
+    pendingThreadId = null;
+    failedThreadId = null;
+    consecutiveFailures = 0;
+    constructor(session) {
+        this.session = session;
+    }
+    settleListeners = new Map();
+    setSettleListener(token, listener) {
+        if (listener === null) {
+            this.settleListeners.delete(token);
+        }
+        else {
+            this.settleListeners.set(token, listener);
+        }
+    }
+    pauseListeners = new Map();
+    setPauseListener(token, listener) {
+        if (listener === null) {
+            this.pauseListeners.delete(token);
+        }
+        else {
+            this.pauseListeners.set(token, listener);
+        }
+    }
+    setDemand(token, demand) {
+        if (demand === null) {
+            this.demands.delete(token);
+        }
+        else {
+            this.demands.set(token, demand);
+        }
+        this._reconcile();
+    }
+    refresh(threadId) {
+        if (!this.busy) {
+            return this._readOnce(threadId);
+        }
+        if (this.followUp === null || this.followUpThreadId !== threadId) {
+            this.followUpThreadId = threadId;
+            this.followUp = (this.flight ?? Promise.resolve()).then(() => {
+                this.followUp = null;
+                this.followUpThreadId = null;
+                return this._readOnce(threadId);
+            });
+        }
+        return this.followUp;
+    }
+    followUp = null;
+    followUpThreadId = null;
+    _reconcile() {
+        let threadId = null;
+        let delegated = false;
+        let stillMoving = false;
+        for (const demand of this.demands.values()) {
+            threadId ??= demand.threadId;
+            delegated ||= demand.delegated;
+            stillMoving ||= demand.stillMoving;
+        }
+        if (this.pendingThreadId !== null && this.pendingThreadId !== threadId) {
+            this.pendingThreadId = null;
+        }
+        if (threadId === null || !delegated) {
+            this._stopTimer();
+            return;
+        }
+        if (this.readThreadId !== threadId) {
+            void this._readOnce(threadId);
+        }
+        if (!stillMoving) {
+            this._stopTimer();
+            return;
+        }
+        if (this.timer === null || this.timerThreadId !== threadId) {
+            this._stopTimer();
+            void this._readOnce(threadId);
+            this.timerThreadId = threadId;
+            this.timer = window.setInterval(() => {
+                void this._readOnce(threadId);
+            }, POLL_INTERVAL_MS);
+        }
+    }
+    _sameAsCurrent(next) {
+        const current = this.cell.get();
+        if (current?.threadId !== next.threadId) {
+            return false;
+        }
+        if (current.map.size !== next.map.size) {
+            return false;
+        }
+        for (const [ordinal, dispatch] of next.map) {
+            const held = current.map.get(ordinal);
+            if (held?.status !== dispatch.status ||
+                held.error !== dispatch.error ||
+                held.updated_at !== dispatch.updated_at) {
+                return false;
+            }
+        }
+        return true;
+    }
+    _stopTimer() {
+        if (this.timer !== null) {
+            window.clearInterval(this.timer);
+            this.timer = null;
+            this.timerThreadId = null;
+        }
+    }
+    _readOnce(threadId) {
+        if (this.busy) {
+            if (threadId !== this.readThreadId) {
+                this.pendingThreadId = threadId;
+            }
+            return this.flight ?? Promise.resolve();
+        }
+        this.busy = true;
+        this.readThreadId = threadId;
+        this.generation += 1;
+        const generation = this.generation;
+        let settleFlight;
+        const flight = new Promise((resolve) => {
+            settleFlight = resolve;
+        });
+        this.flight = flight;
+        window.setTimeout(() => {
+            this._releaseBoundedOutRead(threadId, generation);
+            settleFlight();
+        }, READ_BOUND_MS);
+        void this._read(threadId, generation, settleFlight);
+        return flight;
+    }
+    flight = null;
+    generation = 0;
+    _releaseBoundedOutRead(threadId, generation) {
+        if (generation !== this.generation || !this.busy) {
+            return;
+        }
+        this.generation += 1;
+        this.busy = false;
+        this.flight = null;
+        this._noteReadFailure(threadId);
+        this._replayParkedSwitch();
+    }
+    _noteReadFailure(threadId) {
+        this.consecutiveFailures =
+            this.failedThreadId === threadId ? this.consecutiveFailures + 1 : 1;
+        this.failedThreadId = threadId;
+        if (this.consecutiveFailures >= MAX_CONSECUTIVE_READ_FAILURES &&
+            this.timerThreadId === threadId) {
+            this._stopTimer();
+        }
+        if (this.cell.get()?.threadId !== threadId) {
+            this.readThreadId = null;
+        }
+    }
+    _replayParkedSwitch() {
+        const pending = this.pendingThreadId;
+        this.pendingThreadId = null;
+        if (pending !== null && pending !== this.readThreadId) {
+            void this._readOnce(pending);
+        }
+    }
+    adoptedThrough = 0;
+    async _read(threadId, generation, settleFlight) {
+        const live = () => generation === this.generation;
+        try {
+            const dispatches = await listThreadDispatches(this.session, threadId);
+            const adopts = live() ||
+                (generation > this.adoptedThrough &&
+                    (this.readThreadId === threadId || this.readThreadId === null));
+            if (!adopts) {
+                if (this.failedThreadId === threadId) {
+                    this.failedThreadId = null;
+                    this.consecutiveFailures = 0;
+                }
+                return;
+            }
+            this.readThreadId ??= threadId;
+            this.adoptedThrough = generation;
+            const previous = this.cell.get();
+            const next = {
+                threadId,
+                map: new Map(dispatches.map((dispatch) => [dispatch.ordinal, dispatch])),
+            };
+            if (!this._sameAsCurrent(next)) {
+                this.cell.set(next);
+            }
+            this.failedThreadId = null;
+            this.consecutiveFailures = 0;
+            if (_observedASettle(previous, next)) {
+                _fireEach(this.settleListeners);
+            }
+            if (_observedAPause(previous, next)) {
+                _fireEach(this.pauseListeners);
+            }
+        }
+        catch {
+            if (!live()) {
+                return;
+            }
+            this._noteReadFailure(threadId);
+        }
+        finally {
+            if (live()) {
+                this.busy = false;
+                this.flight = null;
+                settleFlight();
+                this._replayParkedSwitch();
+            }
+        }
+    }
+}
+function _fireEach(listeners) {
+    for (const listener of new Set(listeners.values())) {
+        try {
+            listener();
+        }
+        catch {
+        }
+    }
+}
+function _observedAPause(previous, next) {
+    const comparable = previous?.threadId === next.threadId ? previous : null;
+    for (const [ordinal, dispatch] of next.map) {
+        if (!dispatchIsPaused(dispatch)) {
+            continue;
+        }
+        const held = comparable?.map.get(ordinal);
+        if (held === undefined ||
+            !dispatchIsPaused(held) ||
+            held.updated_at !== dispatch.updated_at) {
+            return true;
+        }
+    }
+    return false;
+}
+function _observedASettle(previous, next) {
+    if (previous?.threadId !== next.threadId) {
+        return false;
+    }
+    for (const [ordinal, dispatch] of next.map) {
+        if (dispatchIsRunning(dispatch)) {
+            continue;
+        }
+        const held = previous.map.get(ordinal);
+        if (held === undefined || dispatchIsRunning(held)) {
+            return true;
+        }
+    }
+    return false;
+}
+const _ledgers = new WeakMap();
+function _ledgerFor(session) {
+    let ledger = _ledgers.get(session);
+    if (ledger === undefined) {
+        ledger = new ThreadDispatchLedger(session);
+        _ledgers.set(session, ledger);
+    }
+    return ledger;
+}
+export function useThreadDispatches(session, threadId, rows, onDispatchSettled, onDispatchPaused) {
+    const ledger = _ledgerFor(session);
+    const read = useCell(ledger.cell);
+    const map = read !== null && read.threadId === threadId ? read.map : EMPTY_LEDGER;
+    const delegated = useMemo(() => rows.some((row) => row.kind === "subagent-group") ||
+        aResumeAwaitsLedgerTruth(rows, EMPTY_LEDGER), [rows]);
+    const stillMoving = useMemo(() => anySubagentStillRunning(rows, map) || aResumeAwaitsLedgerTruth(rows, map), [rows, map]);
+    const token = useMemo(() => ({}), []);
+    useEffect(() => {
+        if (threadId === null) {
+            return;
+        }
+        ledger.setDemand(token, { threadId, delegated, stillMoving });
+        return () => {
+            ledger.setDemand(token, null);
+        };
+    }, [ledger, token, threadId, delegated, stillMoving]);
+    useEffect(() => {
+        if (onDispatchSettled === undefined) {
+            return;
+        }
+        ledger.setSettleListener(token, onDispatchSettled);
+        return () => {
+            ledger.setSettleListener(token, null);
+        };
+    }, [ledger, token, onDispatchSettled]);
+    useEffect(() => {
+        if (onDispatchPaused === undefined) {
+            return;
+        }
+        ledger.setPauseListener(token, onDispatchPaused);
+        return () => {
+            ledger.setPauseListener(token, null);
+        };
+    }, [ledger, token, onDispatchPaused]);
+    const staleDeliveredOrdinals = useMemo(() => {
+        const delivered = new Set();
+        for (const row of rows) {
+            if (row.kind === "subagent-delivery") {
+                for (const result of row.results) {
+                    delivered.add(result.ordinal);
+                }
+            }
+        }
+        return [...delivered]
+            .filter((ordinal) => {
+            const ledgerRow = map.get(ordinal);
+            return ledgerRow !== undefined && dispatchIsRunning(ledgerRow);
+        })
+            .sort((a, b) => a - b)
+            .join(",");
+    }, [rows, map]);
+    useEffect(() => {
+        if (threadId !== null && staleDeliveredOrdinals !== "") {
+            void ledger.refresh(threadId);
+        }
+    }, [ledger, threadId, staleDeliveredOrdinals]);
+    return map;
+}
+export function useChildDispatch(session, threadId, childSessionId) {
+    const ledger = _ledgerFor(session);
+    const read = useCell(ledger.cell);
+    const dispatch = read !== null && read.threadId === threadId
+        ? newestRowForSession(read.map, childSessionId)
+        : undefined;
+    const stillMoving = dispatch !== undefined && dispatchIsRunning(dispatch);
+    const token = useMemo(() => ({}), []);
+    useEffect(() => {
+        if (threadId === null) {
+            return;
+        }
+        ledger.setDemand(token, { threadId, delegated: true, stillMoving });
+        return () => {
+            ledger.setDemand(token, null);
+        };
+    }, [ledger, token, threadId, stillMoving]);
+    const refreshLedger = useCallback(() => {
+        const newestRow = () => {
+            const now = ledger.cell.get();
+            return now !== null && now.threadId === threadId
+                ? newestRowForSession(now.map, childSessionId)
+                : undefined;
+        };
+        if (threadId === null) {
+            return Promise.resolve(newestRow());
+        }
+        return ledger.refresh(threadId).then(newestRow, newestRow);
+    }, [ledger, threadId, childSessionId]);
+    return { dispatch, refreshLedger };
+}

package/dist/components/use-transcript-folds.d.ts

@@ -0,0 +1,26 @@
+import { type ReactNode } from "react";
+import { type FoldedBlock, type FoldedTranscriptRow, type RunFoldMember } from "../core/run-folds.js";
+import type { MarkerBoundaries } from "../core/transcript-rows.js";
+import type { MessageListSource } from "./message-list-slots.js";
+export type DisplayRow = FoldedTranscriptRow;
+export declare function useMessageListDerivations(source: MessageListSource, { live, typing, turnOpen, markerBoundaries, turnStartIds, decisionSurfacesInShelf, frameClaimsLiveness, emptyFallback, }: {
+    live: boolean;
+    typing: boolean;
+    turnOpen: boolean | undefined;
+    markerBoundaries?: MarkerBoundaries;
+    turnStartIds?: ReadonlySet<string>;
+    decisionSurfacesInShelf: boolean;
+    frameClaimsLiveness: boolean;
+    emptyFallback: ReactNode;
+}): {
+    foldedBlocks: FoldedBlock[] | null;
+    displayRows: readonly FoldedTranscriptRow[];
+    currentTurnStart: number;
+    blockStarts: number[];
+    unrowedAnsweredAsks: import("../headless.js").QuestionSetCardModel[];
+    liveIndex: number;
+    hostEmptySurfaceShown: boolean;
+    livenessClaimant: TrailingLivenessClaimant;
+};
+export type TrailingLivenessClaimant = "tail-row" | "standalone-headline" | "typing-dot" | "none";
+export declare function _foldClaimsLiveness(members: readonly RunFoldMember[], turnLive: boolean): boolean;