@teaflask/assistant 0.0.0 → 0.6.0

package/dist/components/assistant-palette.js

@@ -0,0 +1,20 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { lazy } from "react";
+import { useAssistantAppearance } from "./appearance-context.js";
+import { LazyBody } from "./lazy-body.js";
+import { SurfaceBoundary } from "./surface-boundary.js";
+import { TfDialog } from "./primitives/dialog.js";
+import { useRegisterAssistantSurface } from "./use-register-assistant-surface.js";
+const AssistantPaletteBody = lazy(() => import("./assistant-palette-body.js"));
+export function AssistantPalette(props) {
+    return (_jsx(SurfaceBoundary, { surface: "palette", degrade: "silent", children: _jsx(AssistantPaletteInner, { ...props }) }));
+}
+function AssistantPaletteInner({ open, onOpenChange }) {
+    const { rootProps } = useAssistantAppearance();
+    useRegisterAssistantSurface("transient", open);
+    return (_jsx(TfDialog, { open: open, onOpenChange: onOpenChange, "aria-label": "Assistant", "data-tf-assistant": "", "data-tf-glass": "", "data-tf-assistant-palette": "", ...rootProps, className: "tf:m-auto tf:h-[calc(100dvh-2rem)] tf:w-[calc(100vw-2rem)] tf:flex-col " +
+            "tf:overflow-hidden tf:rounded-tf tf:border " +
+            "tf:text-tf-foreground tf:backdrop:bg-black/20 " +
+            "tf:sm:mt-24 tf:sm:h-[calc(100dvh-12rem)] tf:sm:max-h-144 tf:sm:w-full tf:sm:max-w-2xl", children: open ? (_jsx(LazyBody, { children: _jsx(AssistantPaletteBody, { onOpenChange: onOpenChange }) })) : null }));
+}

package/dist/components/assistant-transcript.d.ts

@@ -0,0 +1,47 @@
+import type { AbstractAgent } from "@ag-ui/client";
+import { type ComponentType, type ReactNode } from "react";
+import type { ApprovalCardModel } from "../core/approval-inbox.js";
+import { type MarkerBoundaries, type TranscriptRow } from "../core/transcript-rows.js";
+import type { TurnAttachment } from "../contract/threads.js";
+import { type MessageViewSlot, type ToolRowSlot, type TranscriptMarkerProps } from "./message-list.js";
+interface TranscriptSlotProps {
+    scrollClassName?: string;
+    messageView?: MessageViewSlot;
+    toolRow?: ToolRowSlot;
+    input?: ReactNode;
+    welcomeScreen?: ReactNode;
+    threadList?: ReactNode;
+}
+export interface AgentTranscriptSource extends TranscriptSlotProps {
+    agent: AbstractAgent;
+    onStreamError: (error: Error) => void;
+    markers?: ComponentType<TranscriptMarkerProps>;
+    markerBoundaries?: MarkerBoundaries;
+    resumeAnchoredIds?: ReadonlySet<string>;
+    deliveryAnchoredIds?: ReadonlySet<string>;
+    turnAttachments?: ReadonlyMap<string, TurnAttachment[]>;
+    frameClaimsLiveness?: boolean;
+    rows?: never;
+    cards?: never;
+    live?: never;
+    turnOpen?: never;
+    decisionSurfacesInShelf?: never;
+}
+export interface RowsTranscriptSource extends TranscriptSlotProps {
+    rows: readonly TranscriptRow[];
+    cards?: readonly ApprovalCardModel[];
+    live?: boolean;
+    turnOpen?: boolean;
+    decisionSurfacesInShelf?: boolean;
+    agent?: never;
+    onStreamError?: never;
+    markers?: never;
+    markerBoundaries?: never;
+    resumeAnchoredIds?: never;
+    deliveryAnchoredIds?: never;
+    turnAttachments?: never;
+    frameClaimsLiveness?: never;
+}
+export type AssistantTranscriptProps = AgentTranscriptSource | RowsTranscriptSource;
+export declare function AssistantTranscript(props: AssistantTranscriptProps): import("react").JSX.Element;
+export {};

package/dist/components/assistant-transcript.js

@@ -0,0 +1,116 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useState, } from "react";
+import { hostFillDeclines } from "../core/host-fill.js";
+import { connectionErrorRecorder, messagesSnapshotRecorder, } from "../core/messages-cell.js";
+import { EMPTY_TOOL_CALL_DISPLAY_ANCHORS, toolCallDisplayRecorder, withToolCallDisplayAnchored, } from "../core/tool-call-display-anchors.js";
+import { EMPTY_TOOL_CANCEL_ANCHORS, toolCancelRecorder, withToolCancelAnchored, } from "../core/tool-cancel-anchors.js";
+import { EMPTY_TOOL_ERROR_ANCHORS, toolErrorRecorder, withToolErrorAnchored, } from "../core/tool-error-anchors.js";
+import { EMPTY_TOOL_OFFLOAD_ANCHORS, toolOffloadRecorder, withToolOffloadAnchored, } from "../core/tool-offload-anchors.js";
+import { EMPTY_TOOL_DENIAL_LEDGER, toolDenialRecorder, withToolDenialMarkerFolded, } from "../core/tool-denial-anchors.js";
+import { EMPTY_TOOL_REFUSAL_ANCHORS, toolRefusalRecorder, withToolRefusalAnchored, } from "../core/tool-refusal-anchors.js";
+import { transcriptBlocksOf, } from "../core/transcript-rows.js";
+import { MessageList, } from "./message-list.js";
+import { HostSlotBoundary } from "./slot-boundary.js";
+import { useLatestRef } from "./use-latest-ref.js";
+export function AssistantTranscript(props) {
+    if (props.agent !== undefined) {
+        return _jsx(AgentModeTranscript, { ...props });
+    }
+    return _jsx(RowsModeTranscript, { ...props });
+}
+const EMPTY_SNAPSHOT = { messages: [], running: false };
+const NO_CARDS = [];
+const NO_IDS = new Set();
+const NO_MAP = new Map();
+function anchorInto(setter, merge) {
+    return (...args) => {
+        setter((previous) => merge(previous, ...args));
+    };
+}
+function useAgentRecording(agent, onStreamError) {
+    const [snapshot, setSnapshot] = useState(null);
+    const [displayAnchors, setDisplayAnchors] = useState(EMPTY_TOOL_CALL_DISPLAY_ANCHORS);
+    const [errorAnchors, setErrorAnchors] = useState(EMPTY_TOOL_ERROR_ANCHORS);
+    const [cancelAnchors, setCancelAnchors] = useState(EMPTY_TOOL_CANCEL_ANCHORS);
+    const [offloadAnchors, setOffloadAnchors] = useState(EMPTY_TOOL_OFFLOAD_ANCHORS);
+    const [refusalAnchors, setRefusalAnchors] = useState(EMPTY_TOOL_REFUSAL_ANCHORS);
+    const [denialLedger, setDenialLedger] = useState(EMPTY_TOOL_DENIAL_LEDGER);
+    const streamErrorRef = useLatestRef(onStreamError);
+    useEffect(() => {
+        const taps = [
+            agent.subscribe(messagesSnapshotRecorder(setSnapshot)),
+            agent.subscribe(connectionErrorRecorder((error) => {
+                streamErrorRef.current(error);
+            })),
+            agent.subscribe(toolCallDisplayRecorder(anchorInto(setDisplayAnchors, withToolCallDisplayAnchored))),
+            agent.subscribe(toolErrorRecorder(anchorInto(setErrorAnchors, withToolErrorAnchored))),
+            agent.subscribe(toolCancelRecorder(anchorInto(setCancelAnchors, withToolCancelAnchored))),
+            agent.subscribe(toolOffloadRecorder(anchorInto(setOffloadAnchors, withToolOffloadAnchored))),
+            agent.subscribe(toolRefusalRecorder(anchorInto(setRefusalAnchors, withToolRefusalAnchored))),
+            agent.subscribe(toolDenialRecorder(anchorInto(setDenialLedger, withToolDenialMarkerFolded))),
+        ];
+        agent.connectAgent().catch(() => undefined);
+        return () => {
+            for (const tap of taps) {
+                tap.unsubscribe();
+            }
+            agent.abortRun();
+            void agent.detachActiveRun().catch(() => undefined);
+        };
+    }, [agent, streamErrorRef]);
+    return {
+        snapshot,
+        displayAnchors,
+        errorAnchors,
+        cancelAnchors,
+        offloadAnchors,
+        refusalAnchors,
+        denialLedger,
+    };
+}
+function AgentModeTranscript({ agent, onStreamError, markers, markerBoundaries, resumeAnchoredIds = NO_IDS, deliveryAnchoredIds = NO_IDS, turnAttachments, frameClaimsLiveness, scrollClassName, messageView, toolRow, input, welcomeScreen, threadList, }) {
+    const { snapshot, displayAnchors, errorAnchors, cancelAnchors, offloadAnchors, refusalAnchors, denialLedger, } = useAgentRecording(agent, onStreamError);
+    const delivered = snapshot ?? EMPTY_SNAPSHOT;
+    const anchors = useMemo(() => ({
+        resumeAnchors: new Map([...resumeAnchoredIds].map((id) => [id, null])),
+        subagentDeliveryAnchors: new Map([...deliveryAnchoredIds].map((id) => [id, []])),
+        toolErrorAnchors: errorAnchors,
+        toolCancelAnchors: cancelAnchors,
+        toolRefusalAnchors: refusalAnchors,
+        toolDenialAnchors: denialLedger.denied,
+        toolCallDisplayAnchors: displayAnchors,
+        turnFailedAnchors: NO_MAP,
+        toolOffloadAnchors: offloadAnchors,
+        toolSchemaAnchors: NO_MAP,
+        blockTimingAnchors: NO_MAP,
+        turnUsageAnchors: NO_MAP,
+        memoryProvenanceAnchors: NO_MAP,
+        memoryAttributionAnchors: NO_MAP,
+    }), [
+        resumeAnchoredIds,
+        deliveryAnchoredIds,
+        errorAnchors,
+        cancelAnchors,
+        offloadAnchors,
+        refusalAnchors,
+        denialLedger.denied,
+        displayAnchors,
+    ]);
+    const blocks = useMemo(() => transcriptBlocksOf(delivered.messages, anchors, delivered.running, undefined, {
+        markerBoundaries,
+        attachmentsByMessageId: turnAttachments,
+    }), [delivered, anchors, markerBoundaries, turnAttachments]);
+    const showWelcome = _welcomeMomentOf(snapshot, blocks.length, welcomeScreen);
+    return (_jsx(TranscriptFrame, { threadList: threadList, input: input, children: _jsx(MessageList, { blocks: blocks, cards: NO_CARDS, turnStartIds: deliveryAnchoredIds, live: delivered.running, turnOpen: delivered.running, markers: markers, markerBoundaries: markerBoundaries, frameClaimsLiveness: frameClaimsLiveness, scrollClassName: scrollClassName, messageView: messageView, toolRow: toolRow, emptyFallback: showWelcome ? (_jsx(HostSlotBoundary, { slot: "welcomeScreen", fallback: null, children: welcomeScreen })) : undefined }) }));
+}
+function _welcomeMomentOf(snapshot, blockCount, welcomeScreen) {
+    return (snapshot !== null && blockCount === 0 && !hostFillDeclines(welcomeScreen));
+}
+function RowsModeTranscript({ rows, cards = NO_CARDS, live, turnOpen, decisionSurfacesInShelf, scrollClassName, messageView, toolRow, input, welcomeScreen, threadList, }) {
+    const showWelcome = rows.length === 0 && !hostFillDeclines(welcomeScreen);
+    return (_jsx(TranscriptFrame, { threadList: threadList, input: input, children: _jsx(MessageList, { rows: rows, cards: cards, live: live, turnOpen: turnOpen, decisionSurfacesInShelf: decisionSurfacesInShelf, scrollClassName: scrollClassName, messageView: messageView, toolRow: toolRow, emptyFallback: showWelcome ? (_jsx(HostSlotBoundary, { slot: "welcomeScreen", fallback: null, children: welcomeScreen })) : undefined }) }));
+}
+function TranscriptFrame({ threadList, input, children, }) {
+    return (_jsxs(_Fragment, { children: [!hostFillDeclines(threadList) ? (_jsx(HostSlotBoundary, { slot: "threadList", fallback: null, children: _jsx("div", { "data-tf-transcript-chrome": "", children: threadList }) })) : null, children, input ?? null] }));
+}

package/dist/components/attachment-chips.d.ts

@@ -0,0 +1,4 @@
+import type { TurnAttachment } from "../contract/threads.js";
+export declare function AttachmentChips({ attachments, }: {
+    attachments: readonly TurnAttachment[];
+}): import("react").JSX.Element | null;

package/dist/components/attachment-chips.js

@@ -0,0 +1,63 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { humanFileSize } from "./human-file-size.js";
+import { FileIcon } from "./icons.js";
+import { useOptionalAssistantSession } from "./teaflask-assistant-provider.js";
+export function AttachmentChips({ attachments, }) {
+    if (attachments.length === 0) {
+        return null;
+    }
+    return (_jsx("div", { className: "tf:flex tf:flex-wrap tf:justify-end tf:gap-2", children: attachments.map((attachment) => attachment.kind === "image" ? (_jsx(AttachmentImage, { attachment: attachment }, attachment.id)) : (_jsx(FileChip, { attachment: attachment }, attachment.id))) }));
+}
+function AttachmentImage({ attachment }) {
+    const url = useAttachmentUrl(attachment.id);
+    if (url === null) {
+        return _jsx(FileChip, { attachment: attachment });
+    }
+    return (_jsx("img", { src: url, alt: attachment.filename, loading: "lazy", className: "tf:max-h-48 tf:max-w-full tf:rounded-lg tf:ring-1 tf:ring-tf-border tf:ring-inset" }));
+}
+function FileChip({ attachment }) {
+    return (_jsxs("span", { className: "tf:inline-flex tf:max-w-full tf:items-center tf:gap-1.5 tf:rounded-lg " +
+            "tf:bg-tf-background tf:px-2.5 tf:py-1.5 tf:text-xs tf:text-tf-foreground " +
+            "tf:ring-1 tf:ring-tf-border tf:ring-inset", title: attachment.filename, children: [_jsx("span", { className: "tf:text-tf-muted-foreground", children: _jsx(FileIcon, {}) }), _jsx("span", { className: "tf:min-w-0 tf:truncate", children: attachment.filename }), _jsx("span", { className: "tf:shrink-0 tf:text-tf-muted-foreground", children: humanFileSize(attachment.byte_size) })] }));
+}
+const URL_REFRESH_FLOOR_MS = 30_000;
+function useAttachmentUrl(attachmentId) {
+    const session = useOptionalAssistantSession();
+    const store = session?.store ?? null;
+    const [url, setUrl] = useState(null);
+    useEffect(() => {
+        if (store === null) {
+            return;
+        }
+        let cancelled = false;
+        let timer;
+        const mintAndScheduleRefresh = (isRefresh) => {
+            store.mintAttachmentDownloadUrl(attachmentId).then((minted) => {
+                if (cancelled) {
+                    return;
+                }
+                setUrl(minted.url);
+                timer = setTimeout(() => {
+                    mintAndScheduleRefresh(true);
+                }, Math.max(URL_REFRESH_FLOOR_MS, minted.expiresAtMs - Date.now()));
+            }, () => {
+                if (cancelled) {
+                    return;
+                }
+                if (isRefresh) {
+                    timer = setTimeout(() => {
+                        mintAndScheduleRefresh(true);
+                    }, URL_REFRESH_FLOOR_MS);
+                }
+            });
+        };
+        mintAndScheduleRefresh(false);
+        return () => {
+            cancelled = true;
+            clearTimeout(timer);
+        };
+    }, [store, attachmentId]);
+    return url;
+}

package/dist/components/child-transcript.d.ts

@@ -0,0 +1,22 @@
+import { type ReactNode } from "react";
+type ChildStatus = "running" | "failed" | "finished";
+export declare function ChildTranscriptPanel({ threadId, childSessionId, variantIndex, opener, onBack, }: {
+    threadId: string;
+    childSessionId: string;
+    variantIndex?: number;
+    opener: HTMLElement | null;
+    onBack: () => void;
+}): import("react").JSX.Element;
+export declare function ChildTranscriptPreview({ threadId, childSessionId, variantIndex, }: {
+    threadId: string;
+    childSessionId: string;
+    variantIndex?: number;
+}): import("react").JSX.Element;
+export declare function ChildTranscriptPreviewFrame({ label, status, duration, variantIndex, children, }: {
+    label: string;
+    status: ChildStatus;
+    duration?: string | null;
+    variantIndex?: number;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export {};

package/dist/components/child-transcript.js

@@ -0,0 +1,120 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { activityTitleOf } from "../core/activity-title.js";
+import { CheckIcon, ChevronLeftIcon, XCircleIcon } from "lucide-react";
+import { useEffect, useMemo, useRef, useSyncExternalStore, } from "react";
+import { dispatchFailed, dispatchIsRunning } from "../contract/dispatches.js";
+import { subagentIdentityTokenOf } from "../core/agent-identity.js";
+import { openingBriefOf, withOpeningBrief } from "../core/subagent-brief.js";
+import { newestToolCallViewOf } from "../core/subagent-presence.js";
+import { settledDurationLabelOf } from "../core/subagent-roster.js";
+import { trailingRowIsStreaming, transcriptRowsOf, } from "../core/transcript-rows.js";
+import { AgentIdentityMark } from "./agent-identity-mark.js";
+import { MessageList } from "./message-list.js";
+import { TfButton } from "./primitives/button.js";
+import { ShimmerText } from "./streaming-states.js";
+import { useSubagentCurrentWorkPublisher } from "./subagent-current-work.js";
+import { SurfaceBoundary } from "./surface-boundary.js";
+import { SubagentDrillInContext } from "./subagent-drill-in.js";
+import { useAssistantSession } from "./teaflask-assistant-provider.js";
+import { useChildReplayStream } from "./use-child-replay-stream.js";
+import { useChildDispatch } from "./use-thread-dispatches.js";
+export function ChildTranscriptPanel({ threadId, childSessionId, variantIndex, opener, onBack, }) {
+    return (_jsx(ChildTranscript, { mode: "panel", threadId: threadId, childSessionId: childSessionId, variantIndex: variantIndex, opener: opener, onBack: onBack }));
+}
+export function ChildTranscriptPreview({ threadId, childSessionId, variantIndex, }) {
+    return (_jsx(ChildTranscript, { mode: "preview", threadId: threadId, childSessionId: childSessionId, variantIndex: variantIndex, opener: null, onBack: () => undefined }));
+}
+export function ChildTranscriptPreviewFrame({ label, status, duration, variantIndex, children, }) {
+    return (_jsxs("div", { role: "region", "aria-label": `Conversation preview: ${label}`, "data-tf-glass": "", "data-tf-child-transcript-preview": "", className: "tf:flex tf:h-full tf:w-full tf:min-h-0 tf:min-w-0 tf:flex-col tf:overflow-hidden tf:rounded-2xl tf:border tf:bg-tf-background", children: [_jsxs("div", { className: "tf:flex tf:items-center tf:gap-2 tf:border-b tf:px-3 tf:py-2.5", children: [_jsx("span", { className: "tf:flex tf:h-6 tf:min-w-6 tf:shrink-0 tf:items-center tf:justify-center tf:px-1", children: _jsx(AgentIdentityMark, { register: "subagent", variantIndex: variantIndex }) }), _jsx(ChildStatusMark, { status: status }), status === "running" ? (_jsx(ShimmerText, { className: "tf:min-w-0 tf:flex-1 tf:grid-cols-1 tf:text-tf-label tf:font-medium tf:text-tf-muted-foreground", children: _jsx("span", { className: "tf:block tf:truncate", title: label, children: activityTitleOf(label) }) })) : (_jsx("span", { className: "tf:min-w-0 tf:flex-1 tf:truncate tf:text-tf-label tf:font-medium", title: label, children: activityTitleOf(label) })), status === "running" ? (_jsx(ShimmerText, { className: "tf:shrink-0 tf:text-xs tf:text-tf-muted-foreground", children: "Working" })) : null, duration != null ? (_jsx("span", { className: "tf:shrink-0 tf:text-xs tf:text-tf-muted-foreground", children: duration })) : null] }), children] }));
+}
+function ChildStatusMark({ status }) {
+    if (status === "running") {
+        return _jsx("span", { "aria-hidden": true, className: "tf:size-4 tf:shrink-0" });
+    }
+    if (status === "failed") {
+        return (_jsxs(_Fragment, { children: [_jsx(XCircleIcon, { "aria-hidden": true, className: "tf:size-4 tf:shrink-0 tf:text-tf-destructive" }), _jsx("span", { className: "tf:sr-only", children: "Failed" })] }));
+    }
+    return (_jsxs(_Fragment, { children: [_jsx(CheckIcon, { "aria-hidden": true, className: "tf:size-4 tf:shrink-0 tf:text-tf-muted-foreground" }), _jsx("span", { className: "tf:sr-only", children: "Finished" })] }));
+}
+function ChildTranscript({ mode, threadId, childSessionId, variantIndex, opener, onBack, }) {
+    const { session, store } = useAssistantSession();
+    const { dispatch, refreshLedger } = useChildDispatch(session, threadId, childSessionId);
+    const running = dispatch !== undefined && dispatchIsRunning(dispatch);
+    const { messages, streamEnd, tailed, slotDenied, anchors, retry } = useChildReplayStream({ session, threadId, childSessionId, refreshLedger });
+    const backRef = usePanelBackFocus(mode, opener);
+    const brief = useOpeningBrief(store, childSessionId);
+    const rows = useMemo(() => transcriptRowsOf(withOpeningBrief(messages, brief, childSessionId), anchors, running), [messages, brief, childSessionId, anchors, running]);
+    const streamLive = running && tailed && streamEnd === "open";
+    const typing = streamLive && !trailingRowIsStreaming(rows);
+    useChildCurrentWorkPublish(childSessionId, rows, streamLive);
+    const duration = dispatch !== undefined
+        ? settledDurationLabelOf(dispatch.created_at, running ? null : dispatch.updated_at)
+        : null;
+    const label = dispatch !== undefined && dispatch.label !== ""
+        ? dispatch.label
+        : "Delegated task";
+    const failed = dispatch !== undefined && dispatchFailed(dispatch);
+    const failureSentence = failed
+        ? (dispatch.error ?? "The subagent failed before it could report back.")
+        : null;
+    const interrupted = streamEnd === "error" && !failed;
+    const status = running ? "running" : failed ? "failed" : "finished";
+    const transcript = (_jsx(ChildTranscriptBody, { failureSentence: failureSentence, interrupted: interrupted, onRetry: retry, waitingForSlot: slotDenied && streamEnd === "open", rows: rows, typing: typing, streamLive: streamLive, running: running, childSessionId: childSessionId }));
+    if (mode === "preview") {
+        return (_jsx(ChildTranscriptPreviewFrame, { label: label, status: status, duration: duration, variantIndex: variantIndex, children: transcript }));
+    }
+    return (_jsx(ChildTranscriptPanelFrame, { label: label, status: status, duration: duration, variantIndex: variantIndex, backRef: backRef, onBack: onBack, children: transcript }));
+}
+function usePanelBackFocus(mode, opener) {
+    const backRef = useRef(null);
+    useEffect(() => {
+        if (mode !== "panel") {
+            return;
+        }
+        backRef.current?.focus();
+        return () => {
+            if (opener?.isConnected) {
+                opener.focus();
+            }
+        };
+    }, [mode, opener]);
+    return backRef;
+}
+function useOpeningBrief(store, childSessionId) {
+    const briefNow = () => openingBriefOf(store.messages.get(), childSessionId);
+    return useSyncExternalStore(store.messages.subscribe, briefNow, briefNow);
+}
+function useChildCurrentWorkPublish(childSessionId, rows, streamLive) {
+    const publishCurrentWork = useSubagentCurrentWorkPublisher();
+    const publishedRef = useRef(false);
+    useEffect(() => {
+        const view = streamLive ? newestToolCallViewOf(rows) : null;
+        if (view !== null) {
+            publishedRef.current = true;
+            publishCurrentWork(childSessionId, view);
+        }
+        else if (publishedRef.current) {
+            publishedRef.current = false;
+            publishCurrentWork(childSessionId, null);
+        }
+    }, [publishCurrentWork, childSessionId, rows, streamLive]);
+    useEffect(() => () => {
+        if (publishedRef.current) {
+            publishCurrentWork(childSessionId, null);
+        }
+    }, [publishCurrentWork, childSessionId]);
+}
+function ChildTranscriptBody({ failureSentence, interrupted, onRetry, waitingForSlot, rows, typing, streamLive, running, childSessionId, }) {
+    return (_jsxs(_Fragment, { children: [failureSentence !== null ? (_jsx("div", { className: "tf:border-b", children: _jsx("p", { className: "tf:mx-auto tf:m-0 tf:w-full tf:max-w-3xl tf:px-4 tf:py-2 tf:text-tf-label tf:text-tf-destructive", children: failureSentence }) })) : null, interrupted ? (_jsx("div", { role: "alert", className: "tf:border-b", children: _jsxs("div", { className: "tf:mx-auto tf:flex tf:w-full tf:max-w-3xl tf:items-center tf:gap-2 tf:px-4 tf:py-2 tf:text-tf-label tf:text-tf-destructive", children: ["The connection to this subagent was interrupted.", _jsx(TfButton, { variant: "ghost", onClick: onRetry, children: "Retry" })] }) })) : null, waitingForSlot ? (_jsx("p", { className: "tf:mx-auto tf:m-0 tf:w-full tf:max-w-3xl tf:px-4 tf:py-3 tf:text-tf-label tf:text-tf-muted-foreground", children: "Waiting for another subagent view to finish\u2026" })) : null, _jsx(SubagentDrillInContext.Provider, { value: null, children: _jsx(SurfaceBoundary, { surface: "child-transcript", children: _jsx(MessageList, { rows: rows, cards: [], typing: typing, live: streamLive, turnOpen: running, placementHolds: running, identityToken: subagentIdentityTokenOf(childSessionId) }) }) })] }));
+}
+function ChildTranscriptPanelFrame({ label, status, duration, variantIndex, backRef, onBack, children, }) {
+    return (_jsxs("div", { role: "dialog", "aria-label": "Subagent transcript", "data-tf-child-transcript": "", tabIndex: -1, className: "tf:absolute tf:inset-0 tf:flex tf:min-h-0 tf:min-w-0 tf:flex-col tf:bg-tf-background", onKeyDown: (event) => {
+            if (event.key !== "Escape") {
+                return;
+            }
+            event.preventDefault();
+            event.stopPropagation();
+            onBack();
+        }, children: [_jsx("div", { className: "tf:border-b", children: _jsxs("div", { className: "tf:mx-auto tf:flex tf:w-full tf:max-w-3xl tf:items-center tf:gap-2 tf:px-4 tf:py-2", children: [_jsxs(TfButton, { ref: backRef, variant: "ghost", onClick: onBack, children: [_jsx(ChevronLeftIcon, { "aria-hidden": true, className: "tf:size-4 tf:shrink-0" }), "Back"] }), _jsx("span", { className: "tf:flex tf:h-6 tf:min-w-6 tf:shrink-0 tf:items-center tf:justify-center tf:px-1", children: _jsx(AgentIdentityMark, { register: "subagent", variantIndex: variantIndex }) }), _jsx(ChildStatusMark, { status: status }), status === "running" ? (_jsxs(_Fragment, { children: [_jsx(ShimmerText, { className: "tf:min-w-0 tf:flex-1 tf:grid-cols-1 tf:text-tf-label tf:font-medium tf:text-tf-muted-foreground", children: _jsx("span", { className: "tf:block tf:truncate", title: label, children: activityTitleOf(label) }) }), _jsx(ShimmerText, { className: "tf:shrink-0 tf:text-xs tf:text-tf-muted-foreground", children: "Working" })] })) : (_jsx("span", { className: "tf:min-w-0 tf:flex-1 tf:truncate tf:text-tf-label tf:font-medium", title: label, children: activityTitleOf(label) })), duration !== null ? (_jsx("span", { className: "tf:shrink-0 tf:text-xs tf:text-tf-muted-foreground", children: duration })) : null] }) }), children] }));
+}

package/dist/components/companion-drawer-body.d.ts

@@ -0,0 +1 @@
+export default function CompanionDrawerBody(): import("react").JSX.Element;

package/dist/components/companion-drawer-body.js

@@ -0,0 +1,33 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect } from "react";
+import { useAssistantAppearance } from "./appearance-context.js";
+import { CompanionMark } from "./companion-mark.js";
+import { ConversationView, SetupErrorState } from "./conversation-view.js";
+import { servedSuggestionsForPath } from "./served-suggestions.js";
+import { useAssistantSession } from "./teaflask-assistant-provider.js";
+import { useAssistantConversation } from "./use-assistant-conversation.js";
+import { useCell } from "./use-store-cell.js";
+export default function CompanionDrawerBody() {
+    const core = useAssistantConversation();
+    const { suggestions } = useAssistantAppearance();
+    const { assistantConfig, ensureAssistantConfig } = useAssistantSession();
+    const served = useCell(assistantConfig);
+    const resumeStoredThread = core.resumeStoredThread;
+    useEffect(() => {
+        resumeStoredThread();
+    }, [resumeStoredThread]);
+    useEffect(() => {
+        if (suggestions === null) {
+            ensureAssistantConfig();
+        }
+    }, [suggestions, ensureAssistantConfig]);
+    const effectiveSuggestions = suggestions ??
+        (served === null
+            ? undefined
+            : servedSuggestionsForPath(served, window.location.pathname));
+    if (core.setupError !== null) {
+        return (_jsx("div", { className: "tf:flex tf:flex-1 tf:items-center tf:justify-center tf:p-6", children: _jsx(SetupErrorState, { message: core.setupError.message, code: core.setupError.code }) }));
+    }
+    return (_jsx(ConversationView, { core: core, surface: "companion", suggestions: effectiveSuggestions, welcomeMark: _jsx("span", { "aria-hidden": true, "data-tf-companion-welcome-mark": "", children: _jsx(CompanionMark, {}) }) }));
+}

package/dist/components/companion-drawer.d.ts

@@ -0,0 +1,10 @@
+import type { PanelDock } from "../persistence/panel-mode.js";
+export declare function CompanionDrawer({ open, exiting, focusOnOpen, onOpenChange, corner, dock, onDockChange, }: {
+    open: boolean;
+    focusOnOpen: boolean;
+    exiting: boolean;
+    onOpenChange: (open: boolean) => void;
+    corner: "bottom-right" | "bottom-left";
+    dock: PanelDock;
+    onDockChange: ((dock: PanelDock) => void) | null;
+}): import("react").JSX.Element;

package/dist/components/companion-drawer.js

@@ -0,0 +1,88 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { lazy, useId, useRef, useState } from "react";
+import { useAssistantAppearance } from "./appearance-context.js";
+import { CompanionHeaderTitle, CompanionHistoryMenu, } from "./companion-history-menu.js";
+import { CompanionModeMenu, CompanionModeTrigger, } from "./companion-mode-menu.js";
+import { ComposeIcon, MinimizeIcon } from "./icons.js";
+import { LazyBody } from "./lazy-body.js";
+import { TfButton } from "./primitives/button.js";
+import { TfFloatingPanel } from "./primitives/floating-panel.js";
+import { useAssistantConversation } from "./use-assistant-conversation.js";
+const CompanionDrawerBody = lazy(() => import("./companion-drawer-body.js"));
+export function CompanionDrawer({ open, exiting, focusOnOpen, onOpenChange, corner, dock, onDockChange, }) {
+    const { rootProps } = useAssistantAppearance();
+    const core = useAssistantConversation();
+    const menus = useDrawerMenus(onDockChange, onOpenChange);
+    return (_jsxs(TfFloatingPanel, { open: open, focusOnOpen: focusOnOpen, onOpenChange: menus.changeOpenAndSettleMenu, corner: corner, dock: dock, "aria-label": "Assistant", ...rootProps, children: [_jsxs("div", { "data-tf-swipe-handle": "", className: "tf:relative tf:flex tf:h-12 tf:shrink-0 tf:items-center tf:gap-1 tf:border-b tf:pr-2 tf:pl-4", children: [_jsx("span", { "aria-hidden": true, "data-tf-companion-grabber": "" }), _jsx(CompanionHeaderTitle, { menuId: menus.historyMenuId, open: menus.historyOpen, onOpenChange: menus.discloseHistory, triggerRef: menus.historyTriggerRef }), core.setupError === null ? (_jsx(NewConversationButton, { onStart: core.startNewConversation })) : null, onDockChange !== null ? (_jsx(CompanionModeTrigger, { menuId: menus.modeMenuId, open: menus.modeMenuOpen, onOpenChange: menus.discloseModeMenu, triggerRef: menus.modeTriggerRef })) : null, _jsx(TfButton, { variant: "icon", "aria-label": "Minimize assistant", title: "Minimize assistant", onClick: menus.minimize, children: _jsx(MinimizeIcon, {}) })] }), open || exiting ? (_jsx(LazyBody, { children: _jsx(CompanionDrawerBody, {}) })) : null, open && menus.historyOpen ? (_jsx(CompanionHistoryMenu, { id: menus.historyMenuId, onClose: menus.closeHistory, triggerRef: menus.historyTriggerRef })) : null, open && menus.modeMenuOpen && onDockChange !== null ? (_jsx(CompanionModeMenu, { id: menus.modeMenuId, dock: dock, triggerRef: menus.modeTriggerRef, onClose: menus.closeModeMenu, onSelect: menus.selectDock })) : null] }));
+}
+function useDrawerMenus(onDockChange, onOpenChange) {
+    const [historyOpen, setHistoryOpen] = useState(false);
+    const historyMenuId = useId();
+    const historyTriggerRef = useRef(null);
+    const [modeMenuOpen, setModeMenuOpen] = useState(false);
+    const modeMenuId = useId();
+    const modeTriggerRef = useRef(null);
+    if (onDockChange === null && modeMenuOpen) {
+        setModeMenuOpen(false);
+    }
+    function discloseHistory(next) {
+        if (next) {
+            setModeMenuOpen(false);
+        }
+        setHistoryOpen(next);
+    }
+    function discloseModeMenu(next) {
+        if (next) {
+            setHistoryOpen(false);
+        }
+        setModeMenuOpen(next);
+    }
+    function closeHistory() {
+        setHistoryOpen(false);
+    }
+    function closeModeMenu() {
+        setModeMenuOpen(false);
+    }
+    function selectDock(next) {
+        setModeMenuOpen(false);
+        if (onDockChange !== null) {
+            onDockChange(next);
+        }
+        modeTriggerRef.current?.focus();
+    }
+    function changeOpenAndSettleMenu(next) {
+        if (!next) {
+            setHistoryOpen(false);
+            setModeMenuOpen(false);
+        }
+        onOpenChange(next);
+    }
+    function minimize() {
+        changeOpenAndSettleMenu(false);
+    }
+    return {
+        historyOpen,
+        historyMenuId,
+        historyTriggerRef,
+        modeMenuOpen,
+        modeMenuId,
+        modeTriggerRef,
+        discloseHistory,
+        discloseModeMenu,
+        closeHistory,
+        closeModeMenu,
+        selectDock,
+        changeOpenAndSettleMenu,
+        minimize,
+    };
+}
+function NewConversationButton({ onStart }) {
+    return (_jsx(TfButton, { variant: "icon", "aria-label": "New conversation", title: "New conversation", onClick: (event) => {
+            onStart();
+            const panel = event.currentTarget.closest("[data-tf-floating-panel]");
+            requestAnimationFrame(() => {
+                panel?.querySelector("[data-tf-autofocus]")?.focus();
+            });
+        }, children: _jsx(ComposeIcon, {}) }));
+}

package/dist/components/companion-header-disclosure.d.ts

@@ -0,0 +1,20 @@
+import { type ComponentProps, type ReactNode, type RefObject } from "react";
+import { TfButton } from "./primitives/button.js";
+export declare function HeaderDisclosureTrigger({ menuId, open, onOpenChange, triggerRef, children, ...buttonProps }: {
+    menuId: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    triggerRef: RefObject<HTMLButtonElement | null>;
+    children: ReactNode;
+} & Omit<ComponentProps<typeof TfButton>, "onClick" | "onKeyDown" | "ref">): import("react").JSX.Element;
+export declare function HeaderDisclosureMenu({ id, onClose, triggerRef, triggerId, "aria-label": ariaLabel, className, insetFromSurfaceTop, autoFocusFirstButton, children, }: {
+    id: string;
+    onClose: () => void;
+    triggerRef?: RefObject<HTMLButtonElement | null>;
+    triggerId?: string;
+    "aria-label": string;
+    className?: string;
+    insetFromSurfaceTop?: boolean;
+    autoFocusFirstButton?: boolean;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/components/companion-header-disclosure.js

@@ -0,0 +1,63 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef, } from "react";
+import { TfButton } from "./primitives/button.js";
+import { cx } from "./primitives/cx.js";
+export function HeaderDisclosureTrigger({ menuId, open, onOpenChange, triggerRef, children, ...buttonProps }) {
+    return (_jsx(TfButton, { ref: triggerRef, "aria-expanded": open, "aria-controls": menuId, ...buttonProps, onClick: () => {
+            onOpenChange(!open);
+        }, onKeyDown: (event) => {
+            if (!open || event.key !== "Escape") {
+                return;
+            }
+            event.preventDefault();
+            event.stopPropagation();
+            onOpenChange(false);
+        }, children: children }));
+}
+export function HeaderDisclosureMenu({ id, onClose, triggerRef, triggerId, "aria-label": ariaLabel, className, insetFromSurfaceTop = false, autoFocusFirstButton = true, children, }) {
+    const menuRef = useRef(null);
+    useEffect(() => {
+        const menu = menuRef.current;
+        if (menu === null) {
+            return;
+        }
+        const closeUnlessInside = (event) => {
+            const path = event.composedPath();
+            if (path.includes(menu)) {
+                return;
+            }
+            const trigger = triggerRef?.current ??
+                (triggerId === undefined
+                    ? null
+                    : menu.ownerDocument.getElementById(triggerId));
+            if (trigger !== null && path.includes(trigger)) {
+                return;
+            }
+            onClose();
+        };
+        const doc = menu.ownerDocument;
+        doc.addEventListener("pointerdown", closeUnlessInside);
+        return () => {
+            doc.removeEventListener("pointerdown", closeUnlessInside);
+        };
+    }, [onClose, triggerId, triggerRef]);
+    useEffect(() => {
+        if (autoFocusFirstButton) {
+            menuRef.current?.querySelector("button")?.focus();
+        }
+    }, [autoFocusFirstButton]);
+    return (_jsx("div", { ref: menuRef, id: id, role: "dialog", "aria-label": ariaLabel, "data-tf-glass": "", "data-tf-disclosure": "", "data-tf-surface-inset": insetFromSurfaceTop ? "" : undefined, className: cx("tf:absolute tf:top-14 tf:flex tf:max-h-96 tf:flex-col tf:overflow-hidden tf:rounded-2xl tf:border", className), onKeyDown: (event) => {
+            if (event.key !== "Escape") {
+                return;
+            }
+            event.preventDefault();
+            event.stopPropagation();
+            onClose();
+            const trigger = triggerRef?.current ??
+                (triggerId === undefined
+                    ? null
+                    : menuRef.current?.ownerDocument.getElementById(triggerId));
+            trigger?.focus();
+        }, children: children }));
+}

package/dist/components/companion-history-menu.d.ts

@@ -0,0 +1,15 @@
+import { type RefObject } from "react";
+export declare function CompanionHeaderTitle({ menuId, open, onOpenChange, triggerRef, fallbackTitle, }: {
+    menuId: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    triggerRef: RefObject<HTMLButtonElement | null>;
+    fallbackTitle?: string;
+}): import("react").JSX.Element;
+export declare function CompanionHistoryMenu({ id, onClose, triggerRef, triggerId, insetFromSurfaceTop, }: {
+    id: string;
+    onClose: () => void;
+    triggerRef?: RefObject<HTMLButtonElement | null>;
+    triggerId?: string;
+    insetFromSurfaceTop?: boolean;
+}): import("react").JSX.Element;