@teaflask/assistant 0.0.0 → 0.6.0

package/dist/components/tool-call-rows.js

@@ -0,0 +1,103 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useContext } from "react";
+import { approvalAwaitsMember, elicitationAwaitsMember, } from "../core/suspension-queue.js";
+import { ApprovalCard } from "./approval-card.js";
+import { anchoredCardsFor } from "./approval-context.js";
+import { anchoredElicitationsFor, ElicitationsContext, } from "./elicitation-context.js";
+import { settledQuestionsReceiptOf } from "../core/question-receipt.js";
+import { prettyPrintParameters } from "./pretty-print.js";
+import { QuestionPanel } from "./question-panel.js";
+import { HostSlotBoundary, SlotOrDefault } from "./slot-boundary.js";
+import { SurfaceBoundary } from "./surface-boundary.js";
+import { ToolRow } from "./tool-row.js";
+export function ToolCallRows({ row, cards, inCurrentTurn = false, decisionSurfacesInShelf = false, toolRow, }) {
+    const { cards: elicitationCards } = useContext(ElicitationsContext);
+    const settledQuestions = settledQuestionsReceiptOf(row.toolName, row.argsText, row.result);
+    const anchoredApprovals = decisionSurfacesInShelf
+        ? cards.filter((card) => card.toolCallId === row.toolCallId)
+        : anchoredCardsFor(cards, row.toolCallId);
+    const anchoredElicitations = decisionSurfacesInShelf
+        ? elicitationCards.filter((card) => card.toolCallId === row.toolCallId)
+        : anchoredElicitationsFor(elicitationCards, row.toolCallId);
+    const awaitingInput = settledQuestions === null &&
+        _awaitsMemberDecision(anchoredApprovals, anchoredElicitations);
+    const stateWord = _mandatoryStateWordOf(row.state, awaitingInput);
+    const decisionBearing = row.decisionBearing === true ||
+        anchoredApprovals.length > 0 ||
+        anchoredElicitations.length > 0;
+    const view = _toolViewOf(row);
+    if (settledQuestions !== null && view.display?.view === undefined) {
+        view.display = {
+            ...view.display,
+            icon: "question",
+            view: { key: "teaflask.questions", version: 1 },
+        };
+    }
+    const packageToolRow = (_jsx(ToolRow, { view: view, awaitingInput: awaitingInput, decisionBearing: decisionBearing, inCurrentTurn: inCurrentTurn }));
+    return (_jsxs(_Fragment, { children: [toolRow === undefined ? (packageToolRow) : (_jsx(HostSlotBoundary, { slot: "toolRow", fallback: packageToolRow, children: _jsx(SlotOrDefault, { render: () => toolRow({ row, view, awaitingInput }), fallback: packageToolRow, filledAnnex: stateWord !== null ? (_jsx("span", { className: "tf:sr-only", "data-tf-tool-state": row.state, children: stateWord })) : undefined }) })), decisionSurfacesInShelf || settledQuestions !== null ? null : (_jsxs(_Fragment, { children: [anchoredApprovals.map((card) => (_jsx(SurfaceBoundary, { surface: "approval-card", children: _jsx(ApprovalCard, { card: card }) }, card.interruptId))), anchoredElicitations.map((card) => (_jsx(SurfaceBoundary, { surface: "question-panel", children: _jsx(QuestionPanel, { card: card }) }, card.interruptId)))] }))] }));
+}
+function _awaitsMemberDecision(anchoredApprovals, anchoredElicitations) {
+    return (anchoredApprovals.some(approvalAwaitsMember) ||
+        anchoredElicitations.some(elicitationAwaitsMember));
+}
+function _mandatoryStateWordOf(state, awaitingInput) {
+    if (state === "output-error") {
+        return "Failed";
+    }
+    if (state === "denied") {
+        return "Not approved";
+    }
+    if (state === "cancelled" || state === "superseded") {
+        return "Interrupted";
+    }
+    if (state === "refused") {
+        return "Declined";
+    }
+    if (awaitingInput) {
+        return "Needs input";
+    }
+    return null;
+}
+function _toolViewOf(row) {
+    const offloaded = row.offloaded &&
+        row.errorText === undefined &&
+        row.state !== "denied" &&
+        row.state !== "cancelled" &&
+        row.state !== "refused";
+    return {
+        toolName: row.toolName,
+        state: row.state,
+        toolCallId: row.toolCallId,
+        input: _prettyArgsOf(row.argsText),
+        argsText: row.argsText,
+        output: row.errorText !== undefined ||
+            row.state === "denied" ||
+            row.state === "cancelled" ||
+            row.state === "refused" ||
+            offloaded
+            ? undefined
+            : row.result,
+        offloaded: offloaded || undefined,
+        errorText: row.errorText,
+        ...(row.refusalText !== undefined ? { refusalText: row.refusalText } : {}),
+        display: row.display,
+        ...(row.schemas?.argsSchema !== undefined
+            ? { argsSchema: row.schemas.argsSchema }
+            : {}),
+        ...(row.schemas?.resultSchema !== undefined
+            ? { resultSchema: row.schemas.resultSchema }
+            : {}),
+    };
+}
+function _prettyArgsOf(argsText) {
+    if (argsText === "") {
+        return "";
+    }
+    try {
+        return prettyPrintParameters(JSON.parse(argsText));
+    }
+    catch {
+        return argsText;
+    }
+}

package/dist/components/tool-row.d.ts

@@ -0,0 +1,7 @@
+import { type ToolCallViewModel } from "../core/tool-call-display.js";
+export declare function ToolRow({ view, awaitingInput, decisionBearing, inCurrentTurn, }: {
+    view: ToolCallViewModel;
+    awaitingInput?: boolean;
+    decisionBearing?: boolean;
+    inCurrentTurn?: boolean;
+}): import("react").JSX.Element;

package/dist/components/tool-row.js

@@ -0,0 +1,34 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import {} from "../core/tool-call-display.js";
+import { toolCallPresentationOf } from "../core/tool-call-presentation.js";
+import { OperationMark, StatePill } from "./operation-icons.js";
+import { Disclosure, DisclosureChevron } from "./primitives/disclosure.js";
+import { ShimmerText } from "./streaming-states.js";
+import { useToolViewRegistry } from "./tool-view-registry-context.js";
+import { ToolViewIconSlot, ToolViewSlot } from "./tool-view-slot.js";
+import { humanFailureSentenceOf } from "./tool-views/view-dom.js";
+function heldOpenOf(view, toolView, decision) {
+    const hostViewBearing = toolView.views.some((candidate) => candidate.rung <= 2);
+    return (isCleanState(view.state) &&
+        view.offloaded !== true &&
+        (hostViewBearing || decision) &&
+        toolView.call.truncated !== true);
+}
+function isCleanState(state) {
+    return (state === "input-streaming" ||
+        state === "input-available" ||
+        state === "output-available");
+}
+export function ToolRow({ view, awaitingInput = false, decisionBearing, inCurrentTurn = false, }) {
+    const presentation = toolCallPresentationOf(view, useToolViewRegistry(), {
+        awaitingDecision: awaitingInput,
+    });
+    const toolView = presentation.toolView;
+    const heldRowOpen = inCurrentTurn &&
+        heldOpenOf(view, toolView, decisionBearing ?? awaitingInput);
+    return (_jsxs(Disclosure, { variant: "bare", open: heldRowOpen || undefined, ...(view.toolCallId !== undefined && view.toolCallId !== ""
+            ? { rootDataAttributes: { "data-tf-tool-call-id": view.toolCallId } }
+            : {}), className: "tf:w-full", summaryClassName: "tf:flex tf:w-fit tf:items-center tf:gap-3 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:gap-2 tf:pt-1 tf:pb-2 tf:ps-7", summary: _jsxs(_Fragment, { children: [toolView.icons.length === 0 ? (_jsx(OperationMark, { icon: presentation.icon, status: presentation.status })) : (_jsx(ToolViewIconSlot, { icons: toolView.icons, call: toolView.call, icon: presentation.icon })), presentation.status === "input-available" ? (_jsx(ShimmerText, { className: "tf:leading-none", children: presentation.headline })) : (_jsx("span", { className: "tf:leading-none", children: presentation.headline })), presentation.status === "output-error" ? (_jsx(StatePill, { destructive: true, children: "Failed" })) : presentation.status === "denied" ? (_jsx(StatePill, { children: "Not approved" })) : presentation.status === "cancelled" ||
+                    presentation.status === "superseded" ? (_jsx(StatePill, { children: "Interrupted" })) : presentation.status === "refused" ? (_jsx(StatePill, { children: "Declined" })) : awaitingInput ? (_jsx(StatePill, { children: "Needs input" })) : null, _jsx(DisclosureChevron, { revealOnInteraction: true })] }), children: [_jsx("div", { "data-tf-semantic-view": "", className: "tf:mt-1", children: _jsx(ToolViewSlot, { views: toolView.views, call: toolView.call }) }), view.offloaded === true && (_jsx("p", { className: "tf:text-xs tf:text-tf-muted-foreground", children: "This result was too long to show in full, so the assistant worked from a shortened preview." })), view.refusalText !== undefined && (_jsx("p", { "data-tf-refusal-reason": "", className: "tf:text-xs tf:text-tf-muted-foreground", children: view.refusalText })), view.errorText !== undefined && (_jsx("p", { "data-tf-error-reason": "", className: "tf:text-xs tf:text-tf-muted-foreground", children: humanFailureSentenceOf(view.errorText) }))] }));
+}

package/dist/components/tool-view-registry-context.d.ts

@@ -0,0 +1,3 @@
+import type { ToolViewRegistry } from "../core/tool-view.js";
+export declare const ToolViewRegistryContext: import("react").Context<Readonly<Record<string, import("../headless.js").ToolViewRegistration>> | null>;
+export declare function useToolViewRegistry(): ToolViewRegistry | undefined;

package/dist/components/tool-view-registry-context.js

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

package/dist/components/tool-view-slot.d.ts

@@ -0,0 +1,11 @@
+import type { ResolvedToolView, ResolvedToolViewIcon, ToolViewCall } from "../core/tool-view.js";
+import type { ToolCallIcon } from "../core/tool-call-presentation.js";
+export declare function ToolViewSlot({ views, call, }: {
+    views: readonly ResolvedToolView[];
+    call: ToolViewCall;
+}): import("react").JSX.Element;
+export declare function ToolViewIconSlot({ icons, call, icon, }: {
+    icons: readonly ResolvedToolViewIcon[];
+    call: ToolViewCall;
+    icon: ToolCallIcon;
+}): import("react").JSX.Element;

package/dist/components/tool-view-slot.js

@@ -0,0 +1,171 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState, } from "react";
+import { OperationGlyph, OperationMarkFrame } from "./operation-icons.js";
+import { TOOL_VIEW_LATE_FAILURE_EVENT } from "./react-tool-view.js";
+import { useOptionalAssistantSession } from "./teaflask-assistant-provider.js";
+import { DefaultToolView } from "./tool-arguments-summary.js";
+import { useLatestRef } from "./use-latest-ref.js";
+import { useResolvedThemeMode } from "./use-resolved-theme-mode.js";
+export function ToolViewSlot({ views, call, }) {
+    const slotRef = useRef(null);
+    const mountRef = useRef(null);
+    const themeMode = useResolvedThemeMode(slotRef);
+    const props = { call, context: { themeMode } };
+    const active = useMountedAdapter(views, props, mountRef);
+    return (_jsx("div", { ref: slotRef, "data-tf-tool-view": active?.key ?? "", children: active !== undefined ? (_jsx("div", { ref: mountRef, "data-tf-host-view": "", className: "tf:text-xs" })) : (_jsx(DefaultToolView, { call: call, context: { themeMode } })) }));
+}
+export function ToolViewIconSlot({ icons, call, icon, }) {
+    const mountRef = useRef(null);
+    const themeMode = useResolvedThemeMode(mountRef);
+    const props = { call, context: { themeMode } };
+    const active = useMountedAdapter(icons, props, mountRef);
+    return (_jsx(OperationMarkFrame, { status: call.status, children: active !== undefined ? (_jsx("span", { ref: mountRef, "aria-hidden": true, "data-tf-host-view": "", "data-tf-tool-view-icon": active.key })) : (_jsx(OperationGlyph, { icon: icon })) }));
+}
+function useMountedAdapter(candidates, props, nodeRef) {
+    const [failedAdapters, setFailedAdapters] = useState(EMPTY_FAILED);
+    const active = candidates.find((candidate) => !failedAdapters.has(candidate.adapter));
+    const adapter = active?.adapter;
+    const session = useOptionalAssistantSession();
+    const reportErrorRef = useLatestRef(session?.reportError);
+    const heldRef = useRef({
+        instance: null,
+        deliveredProps: null,
+        props,
+        key: active?.key,
+    });
+    const reportedFailuresRef = useRef(new WeakSet());
+    const advancePast = useCallback((failedAdapter, error) => {
+        if (reportedFailuresRef.current.has(failedAdapter)) {
+            return;
+        }
+        reportedFailuresRef.current.add(failedAdapter);
+        _reportThrow(heldRef.current.key ?? "", error, reportErrorRef.current);
+        nodeRef.current?.replaceChildren();
+        heldRef.current.instance = null;
+        heldRef.current.deliveredProps = null;
+        setFailedAdapters((previous) => {
+            if (previous.has(failedAdapter)) {
+                return previous;
+            }
+            const next = new Set(previous);
+            next.add(failedAdapter);
+            return next;
+        });
+    }, [nodeRef, reportErrorRef]);
+    useAdapterMount(adapter, nodeRef, heldRef, advancePast);
+    useAdapterDelivery(adapter, active?.key, props, heldRef, advancePast);
+    return active;
+}
+const EMPTY_FAILED = new Set();
+function useAdapterMount(adapter, nodeRef, heldRef, advancePast) {
+    useEffect(() => {
+        const node = nodeRef.current;
+        const held = heldRef.current;
+        if (adapter === undefined || node === null) {
+            return;
+        }
+        let cancelled = false;
+        let instance = null;
+        const onLateFailure = (event) => {
+            advancePast(adapter, event.detail);
+        };
+        node.addEventListener(TOOL_VIEW_LATE_FAILURE_EVENT, onLateFailure);
+        queueMicrotask(() => {
+            if (cancelled) {
+                return;
+            }
+            try {
+                instance = adapter.mount(node, held.props);
+                held.instance = instance;
+                held.deliveredProps = held.props;
+            }
+            catch (error) {
+                advancePast(adapter, error);
+            }
+        });
+        return () => {
+            cancelled = true;
+            node.removeEventListener(TOOL_VIEW_LATE_FAILURE_EVENT, onLateFailure);
+            held.instance = null;
+            held.deliveredProps = null;
+            const destroyedKey = held.key ?? "";
+            queueMicrotask(() => {
+                if (instance === null) {
+                    return;
+                }
+                try {
+                    instance.destroy();
+                }
+                catch (error) {
+                    console.error(`[teaflask-assistant] The tool view "${destroyedKey}" threw on destroy.`, error);
+                }
+                node.replaceChildren();
+            });
+        };
+    }, [adapter, advancePast, heldRef, nodeRef]);
+}
+function useAdapterDelivery(adapter, key, props, heldRef, advancePast) {
+    useEffect(() => {
+        const held = heldRef.current;
+        held.props = props;
+        held.key = key;
+        if (adapter === undefined) {
+            return;
+        }
+        queueMicrotask(() => {
+            const instance = held.instance;
+            if (instance === null) {
+                return;
+            }
+            const latest = held.props;
+            const delivered = held.deliveredProps;
+            if (delivered !== null && _sameDelivery(delivered, latest)) {
+                return;
+            }
+            held.deliveredProps = latest;
+            try {
+                instance.update(latest);
+            }
+            catch (error) {
+                advancePast(adapter, error);
+            }
+        });
+    });
+}
+function _sameDelivery(previous, next) {
+    const before = previous.call;
+    const after = next.call;
+    return (previous.context.themeMode === next.context.themeMode &&
+        before.toolName === after.toolName &&
+        before.toolCallId === after.toolCallId &&
+        before.status === after.status &&
+        before.awaitingDecision === after.awaitingDecision &&
+        before.resultText === after.resultText &&
+        before.offloaded === after.offloaded &&
+        before.errorText === after.errorText &&
+        before.refusalText === after.refusalText &&
+        before.argsSchema === after.argsSchema &&
+        before.resultSchema === after.resultSchema &&
+        _shallowRecordEqual(before.args, after.args));
+}
+function _shallowRecordEqual(before, after) {
+    if (before === after) {
+        return true;
+    }
+    const keys = Object.keys(before);
+    if (keys.length !== Object.keys(after).length) {
+        return false;
+    }
+    for (const key of keys) {
+        if (!Object.prototype.hasOwnProperty.call(after, key) ||
+            before[key] !== after[key]) {
+            return false;
+        }
+    }
+    return true;
+}
+function _reportThrow(key, error, reportError) {
+    reportError?.(error instanceof Error ? error : new Error(String(error)));
+    console.error(`[teaflask-assistant] The tool view "${key}" threw; the next resolution took over.`, error);
+}

package/dist/components/tool-views/action-view.d.ts

@@ -0,0 +1 @@
+export declare const actionToolView: import("../../headless.js").ToolViewAdapter<Record<string, unknown>, unknown>;

package/dist/components/tool-views/action-view.js

@@ -0,0 +1,111 @@
+import { prettyPrintParameters } from "../pretty-print.js";
+import { CARD_BLOCK_CLASS } from "./parts-classes.js";
+import { actionEnvelopeOf, actionFailureOf, captionRow, card, el, factRows, note, recordOf, scrollRegion, settledOutcomeNotesOf, settledWithResult, statelessToolView, } from "./view-dom.js";
+const REQUEST_SECTIONS = [
+    ["path_params", "Path parameters"],
+    ["query", "Query"],
+    ["body", "Body"],
+];
+const VALUE_PANE_CLASS = "tf:m-0 tf:whitespace-pre-wrap tf:font-mono tf:text-xs tf:text-tf-foreground";
+export const actionToolView = statelessToolView(_renderAction);
+function _renderAction({ call }) {
+    const root = el("div", "tf:flex tf:flex-col tf:gap-2");
+    root.dataset.tfActionView = "";
+    const sections = [];
+    for (const [key, label] of REQUEST_SECTIONS) {
+        const value = call.args[key];
+        if (value === undefined || value === null) {
+            continue;
+        }
+        const record = recordOf(value);
+        if (record !== null && Object.keys(record).length === 0) {
+            continue;
+        }
+        sections.push(captionRow(label), _valueRows(value));
+    }
+    if (sections.length > 0) {
+        root.append(card(sections));
+    }
+    root.append(...settledOutcomeNotesOf(call));
+    if (call.status === "output-error") {
+        _appendFieldProblems(root, call);
+    }
+    if (settledWithResult(call)) {
+        _appendResponse(root, call);
+    }
+    return root;
+}
+function _appendFieldProblems(root, call) {
+    const detail = actionFailureOf(call.errorText)?.detail;
+    const fields = detail?.fields ?? [];
+    if (fields.length === 0) {
+        return;
+    }
+    const rows = factRows(fields.map((field) => [field.path === "" ? "—" : field.path, field.message]));
+    rows.dataset.tfActionFieldProblems = "";
+    const parts = [captionRow("Field problems"), rows];
+    const omitted = detail?.fieldsOmitted ?? 0;
+    if (omitted > 0) {
+        const more = captionRow(`${String(omitted)} more ${omitted === 1 ? "problem" : "problems"} not listed here.`);
+        more.dataset.tfActionFieldProblemsOmitted = String(omitted);
+        parts.push(more);
+    }
+    root.append(card(parts));
+}
+function _valueRows(value) {
+    const record = recordOf(value);
+    if (record !== null) {
+        return scrollRegion([
+            factRows(Object.entries(record).map(([key, entry]) => [key, _valueOf(entry)])),
+        ]);
+    }
+    const wrapper = el("div", CARD_BLOCK_CLASS);
+    wrapper.dataset.tfActionValueBlock = "";
+    wrapper.append(el("pre", VALUE_PANE_CLASS, prettyPrintParameters(value)));
+    return scrollRegion([wrapper]);
+}
+function _valueOf(value) {
+    if (typeof value === "string") {
+        return value === "" ? "—" : value;
+    }
+    if (typeof value === "number" ||
+        typeof value === "boolean" ||
+        typeof value === "bigint") {
+        return String(value);
+    }
+    if (value === null || value === undefined) {
+        return "—";
+    }
+    return el("pre", VALUE_PANE_CLASS, prettyPrintParameters(value));
+}
+function _appendResponse(root, call) {
+    if (call.resultText === undefined) {
+        return;
+    }
+    const envelope = actionEnvelopeOf(call.resultText);
+    if (envelope === null) {
+        root.append(note("The response couldn't be read as an action result and isn't rendered."));
+        return;
+    }
+    const rows = [];
+    let status;
+    if (envelope.status !== null) {
+        status = el("span", envelope.status >= 400
+            ? "tf:font-medium tf:text-tf-destructive"
+            : "tf:text-tf-muted-foreground", `HTTP ${String(envelope.status)}`);
+        status.dataset.tfActionStatus = String(envelope.status);
+    }
+    rows.push(captionRow(envelope.truncated ? "Response (truncated)" : "Response", status));
+    if (envelope.truncated) {
+        rows.push(captionRow("The response body was truncated by the client to fit the size cap."));
+    }
+    if (envelope.body === undefined ||
+        envelope.body === null ||
+        envelope.body === "") {
+        rows.push(captionRow("Empty response body."));
+    }
+    else {
+        rows.push(_valueRows(envelope.body));
+    }
+    root.append(card(rows));
+}

package/dist/components/tool-views/command-view.d.ts

@@ -0,0 +1 @@
+export declare const commandToolView: import("../../headless.js").ToolViewAdapter<Record<string, unknown>, unknown>;

package/dist/components/tool-views/command-view.js

@@ -0,0 +1,46 @@
+import { el, note, recordOf, settledOutcomeNotesOf, settledWithResult, statelessToolView, stringOf, terminal, } from "./view-dom.js";
+const DOCS_NO_OUTPUT_SENTENCE = "The command ran with exit code 0 and produced no output.";
+const INCOMPLETE = "The recorded output is incomplete and isn't rendered.";
+const NO_OUTPUT = "The command produced no output.";
+export const commandToolView = statelessToolView(_renderCommand);
+function _renderCommand({ call }) {
+    const root = el("div", "tf:flex tf:flex-col tf:gap-2");
+    root.dataset.tfCommandView = "";
+    const command = stringOf(call.args.command);
+    const streams = settledWithResult(call) ? _streamsOf(call) : null;
+    const hasCommand = command !== null && command !== "";
+    if (hasCommand || streams?.kind === "streams") {
+        root.append(terminal({
+            command,
+            output: streams?.kind === "streams" ? streams.output : undefined,
+            stderr: streams?.kind === "streams" ? streams.stderr : undefined,
+        }));
+    }
+    root.append(...settledOutcomeNotesOf(call));
+    if (streams?.kind === "note") {
+        root.append(note(streams.text));
+    }
+    return root;
+}
+function _streamsOf(call) {
+    if (call.truncated === true) {
+        return { kind: "note", text: INCOMPLETE };
+    }
+    const result = recordOf(call.result);
+    const output = result === null ? null : stringOf(result.output);
+    const stderr = result === null ? null : stringOf(result.error);
+    if (output !== null && stderr !== null) {
+        return output === "" && stderr === ""
+            ? { kind: "note", text: NO_OUTPUT }
+            : { kind: "streams", output, stderr };
+    }
+    if (call.result === undefined && call.resultText?.startsWith("{") === true) {
+        return { kind: "note", text: INCOMPLETE };
+    }
+    if (call.resultText === undefined) {
+        return null;
+    }
+    return call.resultText === "" || call.resultText === DOCS_NO_OUTPUT_SENTENCE
+        ? { kind: "note", text: NO_OUTPUT }
+        : { kind: "streams", output: call.resultText, stderr: "" };
+}

package/dist/components/tool-views/docs-search-view.d.ts

@@ -0,0 +1,10 @@
+export interface DocsSearchHit {
+    slug: string;
+    anchor: string;
+    title: string;
+    heading: string | null;
+    facts: string | null;
+    content: string;
+}
+export declare const docsSearchToolView: import("../../headless.js").ToolViewAdapter<Record<string, unknown>, unknown>;
+export declare function docsSearchHitsOf(resultText: string): DocsSearchHit[] | null;

package/dist/components/tool-views/docs-search-view.js

@@ -0,0 +1,109 @@
+import { CARD_BLOCK_CLASS, CARD_TITLE_CLASS } from "./parts-classes.js";
+import { badge, boneRows, captionRow, card, el, fileGlyph, listRow, note, pane, scrollRegion, settledOutcomeNotesOf, settledWithResult, statelessToolView, stringOf, } from "./view-dom.js";
+const NO_HITS_SENTENCE = "No documentation sections matched this query.";
+const HIT_HEADLINE = /^\[([^\]#\s]+)#([^\]\s]*)\] (.*)$/;
+const HIT_FACTS = /^Updated: \d{4}-\d{2}-\d{2}( · Verified: \d{4}-\d{2}-\d{2})?$/;
+const EXCERPT_CLASS = "tf:mt-0.5 tf:line-clamp-2 tf:text-xs tf:text-tf-muted-foreground";
+export const docsSearchToolView = statelessToolView(_renderDocsSearch);
+function _renderDocsSearch({ call }) {
+    const root = el("div", "tf:flex tf:flex-col tf:gap-2");
+    root.dataset.tfDocsSearchView = "";
+    const query = stringOf(call.args.query);
+    const title = query === null || query.trim() === ""
+        ? "Results"
+        : `Results for “${query}”`;
+    root.append(...settledOutcomeNotesOf(call));
+    if (!settledWithResult(call) || call.resultText === undefined) {
+        if (call.status === "input-streaming" ||
+            call.status === "input-available") {
+            root.append(call.awaitingDecision
+                ? _proposalCard(query)
+                : el("p", CARD_TITLE_CLASS, title));
+            if (!call.awaitingDecision) {
+                root.append(boneRows(3));
+            }
+        }
+        return root;
+    }
+    if (call.truncated === true) {
+        root.append(note("The recorded results are incomplete and aren't rendered."));
+        return root;
+    }
+    if (call.resultText.trim() === NO_HITS_SENTENCE) {
+        root.append(card([captionRow("No sections matched.")], title));
+        return root;
+    }
+    const hits = docsSearchHitsOf(call.resultText);
+    if (hits === null) {
+        root.append(card([_cardInterior(pane("As recorded", call.resultText))], title));
+        return root;
+    }
+    root.append(card([scrollRegion(hits.map(_hitRow))], title));
+    return root;
+}
+function _proposalCard(query) {
+    const row = listRow({
+        title: query === null || query.trim() === ""
+            ? "Documentation search"
+            : `“${query}”`,
+        secondary: "Search your docs",
+        trailing: badge("Awaiting your decision"),
+    });
+    row.dataset.tfDocsSearchProposal = "";
+    return card([row]);
+}
+export function docsSearchHitsOf(resultText) {
+    const lines = resultText.split("\n");
+    let headline = HIT_HEADLINE.exec(lines[0] ?? "");
+    if (headline === null) {
+        return null;
+    }
+    const hits = [];
+    let start = 1;
+    for (let index = 1; index <= lines.length; index += 1) {
+        const atEnd = index === lines.length;
+        const next = !atEnd && lines[index - 1] === ""
+            ? HIT_HEADLINE.exec(lines[index] ?? "")
+            : null;
+        if (!atEnd && next === null) {
+            continue;
+        }
+        hits.push(_hitOf(headline, lines.slice(start, atEnd ? index : index - 1)));
+        if (next === null) {
+            break;
+        }
+        headline = next;
+        start = index + 1;
+    }
+    return hits;
+}
+function _hitOf(headline, body) {
+    const [, slug, anchor, titleAndHeading] = headline;
+    const separator = titleAndHeading.lastIndexOf(" › ");
+    const title = separator === -1 ? titleAndHeading : titleAndHeading.slice(0, separator);
+    const heading = separator === -1 ? null : titleAndHeading.slice(separator + 3);
+    const facts = HIT_FACTS.test(body[0] ?? "") ? body[0] : null;
+    const content = body.slice(facts === null ? 0 : 1).join("\n");
+    return { slug, anchor, title, heading, facts, content };
+}
+function _cardInterior(child) {
+    const wrapper = el("div", CARD_BLOCK_CLASS);
+    wrapper.append(child);
+    return wrapper;
+}
+function _hitRow(hit) {
+    const where = hit.heading === null || hit.heading === ""
+        ? hit.slug
+        : `${hit.heading} · ${hit.slug}`;
+    const excerpt = hit.content.trim() === ""
+        ? undefined
+        : el("span", EXCERPT_CLASS, hit.content.trim());
+    const row = listRow({
+        icon: fileGlyph(),
+        title: hit.title,
+        secondary: where,
+        below: excerpt,
+    });
+    row.dataset.tfDocsSearchHit = hit.slug;
+    return row;
+}

package/dist/components/tool-views/file-edit-view.d.ts

@@ -0,0 +1 @@
+export declare const fileEditToolView: import("../../headless.js").ToolViewAdapter<Record<string, unknown>, unknown>;