@teaflask/assistant 0.0.0 → 0.6.0

package/dist/components/subagent-delegation-surface.js

@@ -0,0 +1,143 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useId, useMemo, useRef, useState, } from "react";
+import { coworkerIndicesOf, sameCurrentWorkView, } from "../core/subagent-presence.js";
+import { ChildTranscriptPreview } from "./child-transcript.js";
+import { SubagentCurrentWorkContext, SubagentCurrentWorkPublisherContext, } from "./subagent-current-work.js";
+import { SubagentDrillInContext, } from "./subagent-drill-in.js";
+import { SubagentPreviewPopover } from "./subagent-preview-popover.js";
+export function focusIfRestorable(opener) {
+    if (!opener?.isConnected) {
+        return;
+    }
+    const visible = opener.checkVisibility?.({
+        visibilityProperty: true,
+        opacityProperty: true,
+        checkVisibilityCSS: true,
+        checkOpacity: true,
+    }) ?? true;
+    if (visible) {
+        opener.focus();
+        return;
+    }
+    const summary = opener.closest("details")?.querySelector("summary");
+    if (summary instanceof HTMLElement) {
+        summary.focus();
+        return;
+    }
+    if (opener.closest("[data-tf-activity-slot]") !== null) {
+        const root = opener.getRootNode();
+        const jump = root instanceof Document || root instanceof ShadowRoot
+            ? root.querySelector("[data-tf-scroll-away-activity]")
+            : null;
+        if (jump instanceof HTMLElement) {
+            jump.focus();
+        }
+    }
+}
+export function SubagentDelegationSurface({ dispatches, threadId, renderPreview, children, }) {
+    const { previewId, activeDrillIn, anchorRef, previewRef, drillIn } = useSubagentDrillInController(threadId);
+    const { currentWork, publishCurrentWork } = useCurrentWorkPublisher();
+    const label = activeDrillIn !== null
+        ? _drillInLabelOf(dispatches, activeDrillIn.childSessionId)
+        : null;
+    return (_jsx(SubagentDrillInContext.Provider, { value: drillIn, children: _jsx(SubagentCurrentWorkPublisherContext.Provider, { value: publishCurrentWork, children: _jsxs(SubagentCurrentWorkContext.Provider, { value: currentWork, children: [children, activeDrillIn !== null && threadId !== undefined ? (_jsx(SubagentPreviewPopover, { id: previewId, anchorRef: anchorRef, previewRef: previewRef, label: label ?? "Delegated task", children: renderPreview !== undefined ? (renderPreview(activeDrillIn.childSessionId, coworkerIndicesOf(dispatches.values()).get(activeDrillIn.childSessionId))) : (_jsx(ChildTranscriptPreview, { threadId: threadId, childSessionId: activeDrillIn.childSessionId, variantIndex: coworkerIndicesOf(dispatches.values()).get(activeDrillIn.childSessionId) })) }, activeDrillIn.childSessionId)) : null] }) }) }));
+}
+function useSubagentDrillInController(threadId) {
+    const previewId = useId();
+    const [openDrillIn, setOpenDrillIn] = useState(null);
+    const visitToken = useMemo(() => ({ threadId }), [threadId]);
+    const activeDrillIn = openDrillIn !== null && openDrillIn.forVisit === visitToken
+        ? openDrillIn
+        : null;
+    const anchorRef = useMemo(() => ({ current: activeDrillIn?.opener ?? null }), [activeDrillIn]);
+    const previewRef = useRef(null);
+    const close = useCallback(() => {
+        focusIfRestorable(activeDrillIn?.opener ?? null);
+        setOpenDrillIn(null);
+    }, [activeDrillIn]);
+    const dismiss = useCallback(() => {
+        const preview = previewRef.current;
+        const root = preview?.getRootNode();
+        const active = root instanceof Document || root instanceof ShadowRoot
+            ? root.activeElement
+            : null;
+        if (preview !== null && active !== null && preview.contains(active)) {
+            focusIfRestorable(activeDrillIn?.opener ?? null);
+        }
+        setOpenDrillIn(null);
+    }, [activeDrillIn]);
+    const drillIn = useMemo(() => threadId === undefined
+        ? null
+        : {
+            open: (childSessionId, opener) => {
+                setOpenDrillIn({ childSessionId, opener, forVisit: visitToken });
+            },
+            dismiss,
+            openChildSessionId: activeDrillIn?.childSessionId ?? null,
+            previewId,
+        }, [threadId, visitToken, dismiss, activeDrillIn, previewId]);
+    useEffect(() => {
+        if (activeDrillIn === null) {
+            return;
+        }
+        const preview = previewRef.current;
+        if (preview === null) {
+            return;
+        }
+        preview.focus();
+        const closeOnEscape = (event) => {
+            if (event.key !== "Escape" || event.defaultPrevented) {
+                return;
+            }
+            event.preventDefault();
+            event.stopPropagation();
+            close();
+        };
+        const closeUnlessInside = (event) => {
+            const path = event.composedPath();
+            if (path.includes(preview)) {
+                return;
+            }
+            const opener = activeDrillIn.opener;
+            if (opener !== null && path.includes(opener)) {
+                return;
+            }
+            close();
+        };
+        const doc = preview.ownerDocument;
+        preview.addEventListener("keydown", closeOnEscape);
+        doc.addEventListener("pointerdown", closeUnlessInside);
+        return () => {
+            preview.removeEventListener("keydown", closeOnEscape);
+            doc.removeEventListener("pointerdown", closeUnlessInside);
+        };
+    }, [close, activeDrillIn]);
+    return { previewId, activeDrillIn, anchorRef, previewRef, drillIn };
+}
+function useCurrentWorkPublisher() {
+    const [currentWork, setCurrentWork] = useState(() => new Map());
+    const publishCurrentWork = useCallback((childSessionId, view) => {
+        setCurrentWork((previous) => {
+            const held = previous.get(childSessionId);
+            if (view === null) {
+                if (held === undefined) {
+                    return previous;
+                }
+                const next = new Map(previous);
+                next.delete(childSessionId);
+                return next;
+            }
+            if (held !== undefined && sameCurrentWorkView(held, view)) {
+                return previous;
+            }
+            const next = new Map(previous);
+            next.set(childSessionId, view);
+            return next;
+        });
+    }, []);
+    return { currentWork, publishCurrentWork };
+}
+function _drillInLabelOf(dispatches, childSessionId) {
+    return ([...dispatches.values()].find((dispatch) => dispatch.child_session_id === childSessionId && dispatch.label !== "")?.label ?? "Delegated task");
+}

package/dist/components/subagent-delivery-divider.d.ts

@@ -0,0 +1,5 @@
+import type { DeliveredResult } from "../core/subagent-delivery-anchors.js";
+export declare function deliveryDividerLabelOf(results: readonly DeliveredResult[]): string;
+export declare function SubagentDeliveryDivider({ results, }: {
+    results: readonly DeliveredResult[];
+}): import("react").JSX.Element;

package/dist/components/subagent-delivery-divider.js

@@ -0,0 +1,22 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { activityTitleOf } from "../core/activity-title.js";
+import { AgentIdentityMark } from "./agent-identity-mark.js";
+export function deliveryDividerLabelOf(results) {
+    const failed = results.filter((result) => !result.succeeded).length;
+    const succeeded = results.length - failed;
+    const first = results.find((result) => result.label !== "")?.label;
+    const subject = results.length === 1 && first
+        ? `Subagent ${activityTitleOf(first).replace(/[.!?]+$/, "")}`
+        : `${String(results.length)} ${results.length === 1 ? "subagent" : "subagents"}`;
+    if (failed === 0) {
+        return `${subject} done`;
+    }
+    if (results.length === 1) {
+        return `${subject} failed`;
+    }
+    return `${subject} · ${String(succeeded)} done · ${String(failed)} failed`;
+}
+export function SubagentDeliveryDivider({ results, }) {
+    return (_jsxs("div", { "data-tf-system-notice": "", role: "note", "aria-label": "System notification", className: "tf:flex tf:flex-col tf:items-end tf:gap-1.5 tf:py-3 tf:text-xs tf:text-tf-muted-foreground", children: [_jsx("span", { "aria-hidden": true, children: "System notification" }), _jsxs("span", { className: "tf:flex tf:max-w-full tf:items-center tf:gap-2 tf:rounded-full tf:bg-tf-muted tf:px-3 tf:py-2", title: results.map((result) => result.label).join("; "), children: [_jsx("span", { "aria-hidden": true, children: _jsx(AgentIdentityMark, { register: "subagent" }) }), _jsx("span", { className: "tf:min-w-0 tf:truncate", children: deliveryDividerLabelOf(results) })] })] }));
+}

package/dist/components/subagent-drill-in.d.ts

@@ -0,0 +1,8 @@
+export interface SubagentDrillIn {
+    open: (childSessionId: string, opener: HTMLElement | null) => void;
+    dismiss: () => void;
+    openChildSessionId: string | null;
+    previewId: string;
+}
+export declare const SubagentDrillInContext: import("react").Context<SubagentDrillIn | null>;
+export declare function useSubagentDrillIn(): SubagentDrillIn | null;

package/dist/components/subagent-drill-in.js

@@ -0,0 +1,6 @@
+"use client";
+import { createContext, useContext } from "react";
+export const SubagentDrillInContext = createContext(null);
+export function useSubagentDrillIn() {
+    return useContext(SubagentDrillInContext);
+}

package/dist/components/subagent-execution-work.d.ts

@@ -0,0 +1,3 @@
+import type { CoworkerExecutionWork } from "../core/coworker-execution-work.js";
+export declare const SubagentExecutionWorkContext: import("react").Context<ReadonlyMap<number, CoworkerExecutionWork>>;
+export declare function useSubagentExecutionWork(): ReadonlyMap<number, CoworkerExecutionWork>;

package/dist/components/subagent-execution-work.js

@@ -0,0 +1,7 @@
+"use client";
+import { createContext, useContext } from "react";
+const EMPTY_WORK = new Map();
+export const SubagentExecutionWorkContext = createContext(EMPTY_WORK);
+export function useSubagentExecutionWork() {
+    return useContext(SubagentExecutionWorkContext);
+}

package/dist/components/subagent-group-row.d.ts

@@ -0,0 +1,26 @@
+import { type ThreadDispatch } from "../contract/dispatches.js";
+import { type SubagentGroupEntry, type SubagentGroupRow as SubagentGroupRowModel } from "../core/subagent-rows.js";
+import type { CoworkerExecutionWork } from "../core/coworker-execution-work.js";
+export interface SubagentDispatchesJoin {
+    byOrdinal: ReadonlyMap<number, ThreadDispatch>;
+}
+export declare const SubagentDispatchesContext: import("react").Context<SubagentDispatchesJoin>;
+export interface ResolvedSubagentEntry {
+    toolCallId: string;
+    label: string | null;
+    running: boolean;
+    failed: boolean;
+    cancelled: boolean;
+    note: string | null;
+    childSessionId: string | null;
+    identityToken: string | null;
+    ordinal: number | null;
+    paused: boolean;
+    startedAt: string | null;
+    settledAt: string | null;
+}
+export declare function resolvedSubagentEntryOf(entry: SubagentGroupEntry, byOrdinal: ReadonlyMap<number, ThreadDispatch>): ResolvedSubagentEntry;
+export declare function SubagentGroupRow({ row }: {
+    row: SubagentGroupRowModel;
+}): import("react").JSX.Element;
+export declare function coworkerWorkLabelOf(work: CoworkerExecutionWork | undefined, paused: boolean): string | null;

package/dist/components/subagent-group-row.js

@@ -0,0 +1,145 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { activityTitleOf } from "../core/activity-title.js";
+import { ChevronRightIcon } from "lucide-react";
+import { createContext, useContext } from "react";
+import { dispatchFailed, dispatchIsPaused, dispatchIsRunning, } from "../contract/dispatches.js";
+import { subagentIdentityTokenOf } from "../core/agent-identity.js";
+import { coworkerIndicesOf, settledWorkedLabelOf, } from "../core/subagent-presence.js";
+import { subagentGroupHeadlineOf, subagentOutcomeCountsOf, } from "../core/subagent-rows.js";
+import { humanizedToolName, } from "../core/tool-call-display.js";
+import { toolCallPresentationOf } from "../core/tool-call-presentation.js";
+import { AgentIdentityMark } from "./agent-identity-mark.js";
+import { StatePill } from "./operation-icons.js";
+import { TfButton } from "./primitives/button.js";
+import { Disclosure, DisclosureChevron } from "./primitives/disclosure.js";
+import { ShimmerText } from "./streaming-states.js";
+import { useSubagentCurrentWork } from "./subagent-current-work.js";
+import { useSubagentDrillIn } from "./subagent-drill-in.js";
+import { useSubagentExecutionWork } from "./subagent-execution-work.js";
+const EMPTY_SUBAGENT_DISPATCHES = {
+    byOrdinal: new Map(),
+};
+export const SubagentDispatchesContext = createContext(EMPTY_SUBAGENT_DISPATCHES);
+export function resolvedSubagentEntryOf(entry, byOrdinal) {
+    const ledger = entry.receipt != null ? byOrdinal.get(entry.receipt.ordinal) : undefined;
+    const ledgerLabel = ledger !== undefined && ledger.label !== "" ? ledger.label : null;
+    const childSessionId = ledger !== undefined && entry.receipt?.childSessionId != null
+        ? entry.receipt.childSessionId
+        : null;
+    const running = ledger !== undefined ? dispatchIsRunning(ledger) : entry.running;
+    const failed = ledger !== undefined ? dispatchFailed(ledger) : entry.failed;
+    return {
+        toolCallId: entry.toolCallId,
+        label: ledgerLabel ?? entry.label,
+        running,
+        failed,
+        cancelled: entry.cancelled,
+        note: (ledger !== undefined && dispatchFailed(ledger) ? ledger.error : null) ??
+            entry.note,
+        childSessionId,
+        identityToken: childSessionId !== null ? subagentIdentityTokenOf(childSessionId) : null,
+        ordinal: entry.receipt?.ordinal ?? null,
+        paused: ledger !== undefined && dispatchIsPaused(ledger),
+        startedAt: ledger !== undefined ? ledger.created_at : null,
+        settledAt: ledger !== undefined && !running ? ledger.updated_at : null,
+    };
+}
+export function SubagentGroupRow({ row }) {
+    const join = useContext(SubagentDispatchesContext);
+    const resolved = row.entries.map((entry) => resolvedSubagentEntryOf(entry, join.byOrdinal));
+    const counts = subagentOutcomeCountsOf(resolved);
+    const variantIndices = coworkerIndicesOf(join.byOrdinal.values());
+    const currentWork = useSubagentCurrentWork();
+    const executionWork = useSubagentExecutionWork();
+    return (_jsx("div", { "data-tf-subagent-group": "", className: "tf:relative tf:w-full", children: _jsx(Disclosure, { variant: "bare", className: "tf:my-1.5 tf:w-full", open: counts.running > 0 || undefined, summaryClassName: "tf:flex tf:w-fit tf:items-center tf:gap-2 tf:py-1.5 tf:text-tf-label tf:text-tf-muted-foreground tf:hover:text-tf-foreground", bodyClassName: "tf:flex tf:flex-col tf:pt-1 tf:pb-2", summary: _jsxs(_Fragment, { children: [_jsxs("span", { "aria-hidden": true, className: "tf:relative tf:flex tf:size-6 tf:shrink-0 tf:items-center tf:justify-center", children: [_jsx(AgentIdentityMark, { register: "subagent", size: "md" }), counts.failed > 0 ? (_jsx("span", { "aria-hidden": true, className: "tf:absolute tf:-end-0.5 tf:-bottom-0.5 tf:size-2 tf:rounded-full tf:border tf:border-tf-background tf:bg-tf-destructive" })) : null] }), counts.running > 0 ? (_jsx(ShimmerText, { children: subagentGroupHeadlineOf(counts) })) : (_jsx("span", { children: subagentGroupHeadlineOf(counts) })), _jsx(DisclosureChevron, { revealOnInteraction: true })] }), children: _jsx("ul", { className: "tf:m-0 tf:flex tf:list-none tf:flex-col tf:ps-0", children: resolved.map((entry, index) => (_jsx(CoworkerLine, { entry: entry, variantIndex: entry.childSessionId !== null
+                        ? variantIndices.get(entry.childSessionId)
+                        : undefined, currentWorkView: entry.childSessionId !== null
+                        ? currentWork.get(entry.childSessionId)
+                        : undefined, coworkerWork: entry.ordinal !== null
+                        ? executionWork.get(entry.ordinal)
+                        : undefined, last: index === resolved.length - 1 }, entry.toolCallId))) }) }) }));
+}
+function CoworkerLine({ entry, variantIndex, currentWorkView, coworkerWork, last, }) {
+    const drillIn = useSubagentDrillIn();
+    const drillInKey = entry.childSessionId;
+    const note = entry.note;
+    const workedLabel = entry.startedAt !== null
+        ? settledWorkedLabelOf(entry.startedAt, entry.settledAt)
+        : null;
+    const EntrySurface = drillIn !== null && drillInKey !== null ? TfButton : "span";
+    const drillable = drillIn !== null && drillInKey !== null;
+    return (_jsxs("li", { className: "tf:relative tf:flex tf:ps-7 tf:text-tf-label tf:text-tf-foreground", children: [_jsx(CoworkerLineConnectors, { last: last }), _jsxs(EntrySurface, { "data-tf-subagent-entry": "", "data-tf-subagent-identity": entry.identityToken ?? undefined, className: "tf:group/subagent tf:flex tf:min-w-0 tf:flex-1 tf:items-start tf:justify-start tf:gap-2 tf:py-3 tf:text-start tf:text-tf-label tf:font-normal", ...(drillIn !== null && drillInKey !== null
+                    ? {
+                        variant: "bare",
+                        "aria-haspopup": "dialog",
+                        "aria-expanded": drillIn.openChildSessionId === drillInKey,
+                        "aria-controls": drillIn.openChildSessionId === drillInKey
+                            ? drillIn.previewId
+                            : undefined,
+                        onClick: (event) => {
+                            if (drillIn.openChildSessionId === drillInKey)
+                                drillIn.dismiss();
+                            else
+                                drillIn.open(drillInKey, event.currentTarget);
+                        },
+                    }
+                    : {}), children: [_jsx(CoworkerLineOrnaments, { entry: entry, variantIndex: variantIndex, working: currentWorkView !== undefined }), _jsxs("span", { className: "tf:flex tf:min-w-0 tf:flex-1 tf:flex-col tf:gap-1", children: [_jsx(CoworkerLineLabel, { entry: entry, drillable: drillable }), entry.running ? (_jsx(CoworkerLineWork, { currentWorkView: currentWorkView, coworkerWork: coworkerWork, paused: entry.paused })) : null, workedLabel !== null ? (_jsx("span", { "data-tf-subagent-worked": "", className: "tf:m-0 tf:truncate tf:text-xs tf:text-tf-muted-foreground", children: workedLabel })) : null, !entry.running && note !== null ? (_jsx("span", { "data-tf-subagent-note": "", title: note, className: "tf:m-0 tf:truncate tf:text-xs tf:text-tf-muted-foreground", children: note })) : null] })] })] }));
+}
+function CoworkerLineConnectors({ last }) {
+    return (_jsxs(_Fragment, { children: [_jsx("span", { "aria-hidden": true, className: last
+                    ? "tf:pointer-events-none tf:absolute tf:start-2 tf:top-0 tf:h-5.5 tf:w-px tf:bg-tf-border"
+                    : "tf:pointer-events-none tf:absolute tf:start-2 tf:top-0 tf:h-full tf:w-px tf:bg-tf-border" }), _jsx("span", { "aria-hidden": true, className: "tf:pointer-events-none tf:absolute tf:start-2 tf:top-5.5 tf:h-px tf:w-4 tf:bg-tf-border" })] }));
+}
+function CoworkerLineOrnaments({ entry, variantIndex, working, }) {
+    return (_jsxs("span", { "data-tf-subagent-ornaments": "", className: "tf:flex tf:min-h-5 tf:shrink-0 tf:items-center tf:gap-2", children: [entry.running && working ? (_jsx("span", { className: "tf:sr-only", children: "Working" })) : !entry.running && !entry.failed && !entry.cancelled ? (_jsx("span", { className: "tf:sr-only", children: "Finished" })) : null, _jsx("span", { "aria-hidden": true, children: _jsx(AgentIdentityMark, { register: "subagent", variantIndex: variantIndex, className: "tf:text-tf-muted-foreground" }) })] }));
+}
+function CoworkerLineLabel({ entry, drillable, }) {
+    return (_jsxs("span", { className: "tf:flex tf:min-w-0 tf:items-center tf:gap-2", children: [drillable ? (_jsxs("span", { className: "tf:flex tf:min-w-0 tf:items-center tf:gap-1.5", children: [entry.running ? (_jsx("span", { "data-tf-subagent-label": "", title: entry.label ?? undefined, className: "tf:min-w-0 tf:text-tf-muted-foreground", children: _jsx(ShimmerText, { className: "tf:max-w-full tf:grid-cols-1", children: _jsx("span", { className: "tf:block tf:truncate", children: activityTitleOf(entry.label ?? "Delegated task") }) }) })) : (_jsx("span", { "data-tf-subagent-label": "", title: entry.label ?? undefined, className: "tf:min-w-0 tf:truncate", children: activityTitleOf(entry.label ?? "Delegated task") })), _jsx(ChevronRightIcon, { "aria-hidden": true, className: "tf:size-3.5 tf:shrink-0 tf:text-tf-muted-foreground tf:opacity-0 tf:transition-opacity tf:group-hover/subagent:opacity-100 tf:group-focus-visible/subagent:opacity-100 tf:group-aria-expanded/subagent:opacity-100 tf:pointer-coarse:opacity-100" }), _jsx("span", { className: "tf:sr-only", children: "Open this subagent's transcript" })] })) : entry.running ? (_jsx("span", { "data-tf-subagent-label": "", title: entry.label ?? undefined, className: "tf:min-w-0 tf:text-tf-muted-foreground", children: _jsx(ShimmerText, { className: "tf:max-w-full tf:grid-cols-1", children: _jsx("span", { className: "tf:block tf:truncate", children: activityTitleOf(entry.label ?? "Delegated task") }) }) })) : (_jsx("span", { "data-tf-subagent-label": "", title: entry.label ?? undefined, className: "tf:min-w-0 tf:truncate", children: activityTitleOf(entry.label ?? "Delegated task") })), entry.failed ? (_jsx(StatePill, { destructive: true, children: "Failed" })) : entry.cancelled && !entry.running ? (_jsx(StatePill, { children: "Interrupted" })) : null] }));
+}
+export function coworkerWorkLabelOf(work, paused) {
+    if (!paused) {
+        return null;
+    }
+    if (work !== undefined) {
+        const name = work.toolName === null ? "" : humanizedToolName(work.toolName);
+        if (work.via === "approval") {
+            switch (work.status) {
+                case "pending":
+                case "executing":
+                    return name === ""
+                        ? "Waiting for your approval"
+                        : `Waiting for your approval to run ${name}`;
+                case "reported":
+                    if (work.ok === false) {
+                        return name === "" ? "Not approved" : `${name} not approved`;
+                    }
+                    return name === "" ? "Approved" : `Approved ${name}`;
+                case "stale":
+                    break;
+            }
+            return "Paused, waiting on you";
+        }
+        if (name === "") {
+            return "Paused, waiting on you";
+        }
+        switch (work.status) {
+            case "executing":
+                return `Running ${name} in your browser`;
+            case "pending":
+                return `Waiting to run ${name} in your browser`;
+            case "reported":
+                return `${work.ok === false ? `${name} failed` : `Ran ${name}`} in your browser`;
+            case "stale":
+                break;
+        }
+    }
+    return "Paused, waiting on you";
+}
+function CoworkerLineWork({ currentWorkView, coworkerWork, paused, }) {
+    const workLabel = coworkerWorkLabelOf(coworkerWork, paused);
+    if (workLabel !== null) {
+        return (_jsx("span", { className: "tf:m-0 tf:text-xs tf:text-tf-muted-foreground", children: _jsx(ShimmerText, { className: "tf:max-w-full tf:grid-cols-1", children: _jsx("span", { "data-tf-subagent-coworker-work": "", className: "tf:block tf:truncate", children: workLabel }) }) }));
+    }
+    return (_jsx("span", { className: "tf:m-0 tf:text-xs tf:text-tf-muted-foreground", children: _jsx(ShimmerText, { className: "tf:max-w-full tf:grid-cols-1", children: currentWorkView !== undefined ? (_jsx("span", { "data-tf-subagent-current-work": "", className: "tf:block tf:truncate", children: toolCallPresentationOf(currentWorkView).currentWorkLabel })) : (_jsx("span", { className: "tf:block tf:truncate", children: "Working" })) }) }));
+}

package/dist/components/subagent-preview-popover.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode, type RefObject } from "react";
+export declare function SubagentPreviewPopover({ id, anchorRef, previewRef, label, children, }: {
+    id: string;
+    anchorRef: RefObject<HTMLElement | null>;
+    previewRef: RefObject<HTMLDivElement | null>;
+    label: string;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/components/subagent-preview-popover.js

@@ -0,0 +1,78 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect } from "react";
+export function SubagentPreviewPopover({ id, anchorRef, previewRef, label, children, }) {
+    useEffect(() => {
+        const preview = previewRef.current;
+        const anchor = anchorRef.current;
+        if (preview === null || anchor === null) {
+            return;
+        }
+        if (typeof preview.showPopover === "function") {
+            preview.showPopover();
+        }
+        const view = preview.ownerDocument.defaultView;
+        if (view === null) {
+            return;
+        }
+        let placedOnce = false;
+        const place = () => {
+            const anchorRect = anchor.getBoundingClientRect();
+            if (placedOnce && anchorRect.width === 0 && anchorRect.height === 0) {
+                return;
+            }
+            placedOnce = true;
+            const { left, top, width, height } = _previewPlacementOf(anchorRect, view.visualViewport?.width ?? view.innerWidth, view.visualViewport?.height ?? view.innerHeight);
+            preview.style.left = `${String(Math.round(left))}px`;
+            preview.style.top = `${String(Math.round(top))}px`;
+            preview.style.width = `${String(Math.round(width))}px`;
+            preview.style.height = `${String(Math.round(height))}px`;
+        };
+        place();
+        view.addEventListener("resize", place);
+        view.addEventListener("scroll", place, true);
+        view.visualViewport?.addEventListener("resize", place);
+        view.visualViewport?.addEventListener("scroll", place);
+        return () => {
+            view.removeEventListener("resize", place);
+            view.removeEventListener("scroll", place, true);
+            view.visualViewport?.removeEventListener("resize", place);
+            view.visualViewport?.removeEventListener("scroll", place);
+            if (preview.matches(":popover-open")) {
+                preview.hidePopover();
+            }
+        };
+    }, [anchorRef, previewRef]);
+    return (_jsxs("div", { ref: previewRef, id: id, role: "dialog", "aria-label": `Conversation preview: ${label}`, popover: "manual", tabIndex: -1, className: "tf:fixed tf:m-0 tf:overflow-visible tf:border-0 tf:bg-transparent tf:p-0 tf:text-tf-foreground tf:focus-visible:outline-2 tf:focus-visible:outline-offset-2 tf:focus-visible:outline-tf-ring", children: [_jsx("span", { "aria-hidden": true, "data-tf-subagent-preview-hover-bridge": "", className: "tf:pointer-events-auto tf:absolute tf:-inset-2" }), _jsx("div", { className: "tf:relative tf:h-full tf:w-full", children: children })] }));
+}
+function _previewPlacementOf(anchorRect, viewportWidth, viewportHeight) {
+    const gutter = 16;
+    const gap = 8;
+    const preferredSize = viewportWidth >= 768 ? 384 : 320;
+    const width = Math.min(preferredSize, viewportWidth - gutter * 2);
+    const height = Math.min(preferredSize, viewportHeight - gutter * 2);
+    const roomRight = viewportWidth - anchorRect.right - gutter;
+    const roomLeft = anchorRect.left - gutter;
+    let left;
+    let top;
+    if (roomRight >= width + gap) {
+        left = anchorRect.right + gap;
+        top = Math.min(Math.max(anchorRect.top, gutter), viewportHeight - height - gutter);
+    }
+    else if (roomLeft >= width + gap) {
+        left = anchorRect.left - width - gap;
+        top = Math.min(Math.max(anchorRect.top, gutter), viewportHeight - height - gutter);
+    }
+    else {
+        left = Math.min(Math.max(anchorRect.left + (anchorRect.width - width) / 2, gutter), viewportWidth - width - gutter);
+        const above = anchorRect.top - gap - height;
+        const below = anchorRect.bottom + gap;
+        top =
+            above >= gutter
+                ? above
+                : below + height <= viewportHeight - gutter
+                    ? below
+                    : Math.max(gutter, viewportHeight - height - gutter);
+    }
+    return { left, top, width, height };
+}

package/dist/components/subscription-connect-arms.d.ts

@@ -0,0 +1,25 @@
+import type { SubscriptionAuthorization, SubscriptionProvider } from "../contract/subscriptions.js";
+import { type TfButtonVariant } from "./primitives/button.js";
+export declare const NOT_CONNECTED_HEADLINE = "Didn't connect.";
+export declare function notConnectedExplanationOf(name: string): string;
+export declare function planLimitSentenceOf(name: string): string;
+export declare function notEligibleSentenceOf(name: string): string;
+export declare function checkingPlanSentenceOf(name: string): string;
+export declare function manageUsageUrlOf(provider: SubscriptionProvider): string | null;
+export declare function ManageUsageLink({ provider, variant, }: {
+    provider: SubscriptionProvider;
+    variant?: TfButtonVariant;
+}): import("react").JSX.Element | null;
+export declare function HeartbeatLine({ sentence, tone, }: {
+    sentence: string;
+    tone?: "muted" | "foreground";
+}): import("react").JSX.Element;
+export declare function PopupBlocked({ authorization, onCancel, onTabOpened, }: {
+    authorization: SubscriptionAuthorization;
+    onCancel: () => void;
+    onTabOpened: () => void;
+}): import("react").JSX.Element;
+export declare function NotConnected({ name, onBegin, }: {
+    name: string;
+    onBegin: () => void;
+}): import("react").JSX.Element;

package/dist/components/subscription-connect-arms.js

@@ -0,0 +1,43 @@
+"use client";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { TfButton, TfLinkButton, } from "./primitives/button.js";
+export const NOT_CONNECTED_HEADLINE = "Didn't connect.";
+export function notConnectedExplanationOf(name) {
+    return (`Using your ${name} plan here needs ${name} Plus or Pro on a personal account. ` +
+        "If you chose a work workspace, try again and pick your personal account.");
+}
+export function planLimitSentenceOf(name) {
+    return (`Your ${name} plan can't be used here right now. This app may have ` +
+        `reached the usage limit set in ${name}, or plan sharing is turned off.`);
+}
+export function notEligibleSentenceOf(name) {
+    return (`This ${name} account can't share its plan here. ` +
+        `It needs ${name} Plus or Pro on a personal account.`);
+}
+export function checkingPlanSentenceOf(name) {
+    return `Checking your ${name} plan…`;
+}
+const _MANAGE_USAGE_URLS = {
+    openai_chatgpt: "https://chatgpt.com/settings/usage?tab=overview",
+};
+export function manageUsageUrlOf(provider) {
+    return _MANAGE_USAGE_URLS[provider] ?? null;
+}
+export function ManageUsageLink({ provider, variant = "primary", }) {
+    const href = manageUsageUrlOf(provider);
+    if (href === null) {
+        return null;
+    }
+    return (_jsx(TfLinkButton, { href: href, target: "_blank", rel: "noopener noreferrer", variant: variant, children: "Manage usage" }));
+}
+export function HeartbeatLine({ sentence, tone = "muted", }) {
+    return (_jsxs("p", { className: tone === "muted"
+            ? "tf:m-0 tf:flex tf:items-center tf:gap-1.5 tf:text-tf-label tf:text-tf-muted-foreground"
+            : "tf:m-0 tf:flex tf:items-center tf:gap-1.5 tf:text-tf-label tf:text-tf-foreground", role: "status", children: [_jsx("span", { "aria-hidden": true, className: "tf:size-1.5 tf:shrink-0 tf:animate-tf-pulse tf:rounded-full tf:bg-tf-foreground tf:motion-reduce:animate-none" }), sentence] }));
+}
+export function PopupBlocked({ authorization, onCancel, onTabOpened, }) {
+    return (_jsxs("div", { className: "tf:flex tf:flex-col tf:gap-2", children: [_jsx("p", { className: "tf:m-0 tf:text-tf-label tf:text-tf-foreground", role: "status", children: "Your browser blocked the sign-in window." }), _jsxs("div", { className: "tf:flex tf:flex-wrap tf:items-center tf:gap-2", children: [_jsx(TfLinkButton, { href: authorization.authorize_url, target: "_blank", rel: "opener", referrerPolicy: "no-referrer", onClick: onTabOpened, children: "Continue in a new tab" }), _jsx(TfButton, { variant: "ghost", onClick: onCancel, children: "Cancel" })] })] }));
+}
+export function NotConnected({ name, onBegin, }) {
+    return (_jsxs("div", { className: "tf:flex tf:flex-col tf:gap-2", children: [_jsxs("div", { className: "tf:flex tf:flex-col tf:gap-1", role: "status", children: [_jsx("p", { className: "tf:m-0 tf:text-tf-heading tf:font-medium tf:text-tf-foreground", children: NOT_CONNECTED_HEADLINE }), _jsx("p", { className: "tf:m-0 tf:text-tf-label tf:text-tf-muted-foreground", children: notConnectedExplanationOf(name) })] }), _jsx(TfButton, { variant: "primary", className: "tf:self-start", onClick: onBegin, children: "Try again" })] }));
+}

package/dist/components/subscription-connect-flow.d.ts

@@ -0,0 +1,60 @@
+import { type SubscriptionAuthorization, type SubscriptionProvider, type SubscriptionStatus } from "../contract/subscriptions.js";
+import type { TokenSession } from "../transport/token-session.js";
+export declare function providerNameOf(provider: SubscriptionProvider): string;
+export declare const DISCLOSURE_LINE = "Conversations here will use your ChatGPT plan's included usage.";
+type ConnectFlowState = {
+    kind: "idle";
+} | {
+    kind: "starting";
+} | {
+    kind: "in_popup";
+    popup: Window;
+    expiresAt: number;
+} | {
+    kind: "popup_blocked";
+    authorization: SubscriptionAuthorization;
+    expiresAt: number;
+    tabOpened: boolean;
+} | {
+    kind: "completing";
+} | {
+    kind: "checking";
+    before: SubscriptionStatus;
+} | {
+    kind: "landed";
+    before: SubscriptionStatus;
+} | {
+    kind: "removed";
+    before: SubscriptionStatus;
+} | {
+    kind: "not_connected";
+} | {
+    kind: "error";
+    sentence: string;
+};
+interface SubscriptionConnectFlow {
+    flow: ConnectFlowState;
+    flowInProgress: boolean;
+    errorSentence: string | null;
+    begin: () => void;
+    disconnect: () => void;
+    cancel: () => void;
+    noteTabOpened: () => void;
+}
+export declare function useSubscriptionConnectFlow(status: SubscriptionStatus, session: TokenSession, refreshSubscriptions: () => void, noteSignedIn: () => void): SubscriptionConnectFlow;
+export declare function ProviderConnectSection({ status, session, refreshSubscriptions, refreshStandingAndGate, onSignedIn, }: {
+    status: SubscriptionStatus;
+    session: TokenSession;
+    refreshSubscriptions: () => void;
+    refreshStandingAndGate: () => void;
+    onSignedIn: () => void;
+}): import("react").JSX.Element;
+export declare function ConnectFlow({ name, flow, errorSentence, onBegin, onCancel, onTabOpened, }: {
+    name: string;
+    flow: ConnectFlowState;
+    errorSentence: string | null;
+    onBegin: () => void;
+    onCancel: () => void;
+    onTabOpened: () => void;
+}): import("react").JSX.Element;
+export {};