@fungi.computer/parakeet 0.0.0-stage → 0.0.1

package/dist/components/TimelineItem.d.ts

@@ -0,0 +1,15 @@
+import { type ReactNode } from "react";
+import { type ToolDisclosureState } from "../core/tool-groups.js";
+import type { TimelineItem as TimelineRow, ToolItem } from "../store/types.js";
+import { type ToggleToolDisclosure } from "./ToolGroup.js";
+export declare const TimelineItem: import("react").NamedExoticComponent<Readonly<{
+    item: TimelineRow;
+    onDismissFailed?: ((requestId: string) => void) | undefined;
+    renderToolActions?: ((item: ToolItem) => ReactNode) | undefined;
+    renderAssistantAttachment?: ((text: string) => ReactNode) | undefined;
+    formatAssistantText?: ((text: string) => string) | undefined;
+    /** View-only open state for tool groups and calls. */
+    toolDisclosure?: ToolDisclosureState | undefined;
+    /** Flip one tool group or call. */
+    onToggleTool?: ToggleToolDisclosure | undefined;
+}>>;

package/dist/components/TimelineItem.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { memo } from "react";
+import { initialToolDisclosure, } from "../core/tool-groups.js";
+import { assistantMessageVisible } from "../core/assistant-visibility.js";
+import { formatTokenCount } from "../core/format-context.js";
+import { ChatMessage } from "./ChatMessage.js";
+import { ToolGroup } from "./ToolGroup.js";
+const ignoreToggle = () => undefined;
+export const TimelineItem = memo(function TimelineItem({ item, onDismissFailed, renderToolActions, renderAssistantAttachment, formatAssistantText, toolDisclosure = initialToolDisclosure, onToggleTool = ignoreToggle, }) {
+    switch (item.kind) {
+        case "user_message": {
+            const requestId = item.requestId;
+            const dismissAction = requestId === undefined || onDismissFailed === undefined ? null : (_jsx("button", { "aria-label": "Dismiss failed prompt", className: "btn btn-ghost btn-xs", onClick: () => {
+                    onDismissFailed(requestId);
+                }, type: "button", children: "Dismiss" }));
+            return (_jsxs(_Fragment, { children: [item.author ? (_jsx("div", { className: "px-3 text-xs text-dim", "data-author": item.author.id, children: item.author.name })) : null, _jsx(ChatMessage, { pending: item.status !== "confirmed", speaker: "user", children: item.text }), item.status === "failed" ? (_jsxs("div", { className: "flex items-center gap-2 px-3 text-xs text-error", role: "alert", children: [_jsx("span", { children: "Your prompt didn\u2019t make it through." }), dismissAction] })) : null] }));
+        }
+        case "assistant_message":
+            if (!assistantMessageVisible(item))
+                return null;
+            return (_jsxs(_Fragment, { children: [item.author ? (_jsx("div", { className: "px-3 text-xs text-dim", "data-author": item.author.id, children: item.author.name })) : null, _jsx(ChatMessage, { isError: item.isError === true, pending: item.pending, speaker: "agent", ...(item.thinking ? { thinking: item.thinking } : {}), children: formatAssistantText?.(item.text) ?? item.text }), !item.pending && !item.isError
+                        ? renderAssistantAttachment?.(item.text)
+                        : null] }));
+        case "tool_group":
+            return (_jsx(ToolGroup, { disclosure: toolDisclosure, group: item, onToggle: onToggleTool, renderToolActions: renderToolActions }));
+        case "compaction_divider":
+            return (_jsx("div", { className: "divider text-dim my-2 text-xs", role: "separator", children: item.tokensAfter === null
+                    ? "compacted · the agent’s memory starts below"
+                    : `compacted ${formatTokenCount(item.tokensBefore)} → ${formatTokenCount(item.tokensAfter)}` }));
+        case "compaction_notice":
+            return (_jsxs("div", { className: `px-3 text-xs ${item.result === "failed" ? "text-error" : "text-dim"}`, role: "status", children: ["\u00B7", " ", item.result === "failed"
+                        ? "compaction failed"
+                        : "nothing to compact", item.diagnostic === null ? "" : `: ${item.diagnostic}`] }));
+    }
+});

package/dist/components/ToolGroup.d.ts

@@ -0,0 +1,12 @@
+import { type ReactNode } from "react";
+import { type ToolDisclosureState } from "../core/tool-groups.js";
+import type { ToolGroupItem, ToolItem } from "../store/types.js";
+/** Flip one group or call; the caller owns the view-only disclosure state. */
+export type ToggleToolDisclosure = (id: string, defaultOpen: boolean) => void;
+/** Recent finished calls, or a live group, with reader-owned disclosure. */
+export declare const ToolGroup: import("react").NamedExoticComponent<Readonly<{
+    group: ToolGroupItem;
+    disclosure: ToolDisclosureState;
+    onToggle: ToggleToolDisclosure;
+    renderToolActions?: ((item: ToolItem) => ReactNode) | undefined;
+}>>;

package/dist/components/ToolGroup.js

@@ -0,0 +1,90 @@
+import { jsxs as _jsxs, jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { Badge } from "@fungi.computer/caps/components/badge";
+import { DiffView } from "@fungi.computer/caps/components/diff-view";
+import { Disclosure } from "@fungi.computer/caps/components/disclosure";
+import { Status } from "@fungi.computer/caps/components/status";
+import { Sigil } from "@fungi.computer/sigils";
+import { memo } from "react";
+import { disclosureOpen, toolCallDefaultOpen, toolGroupDefaultOpen, visibleToolCalls, } from "../core/tool-groups.js";
+import { formatToolDuration, toolStatusTone as statusTone, toolKindSigils, } from "../core/tool-view.js";
+import { CodeBlock } from "./CodeBlock.js";
+/** Items beyond a section's preview, unless the reader asked for all. */
+function visible(items, preview, full) {
+    return full || items.length <= preview
+        ? { shown: items, hidden: 0 }
+        : { shown: items.slice(0, preview), hidden: items.length - preview };
+}
+function ShowMore({ hidden, onShowAll, }) {
+    if (hidden === 0)
+        return null;
+    return (_jsxs("button", { className: "btn btn-ghost btn-xs text-dim", onClick: onShowAll, type: "button", children: ["Show ", String(hidden), " more lines"] }));
+}
+const monoBlock = "not-prose m-0 overflow-x-auto rounded-lg border border-base-300 bg-base-200 px-sm py-xs font-mono text-[10px] leading-relaxed";
+function SectionView({ section, full, onShowAll, }) {
+    switch (section.kind) {
+        case "diff": {
+            const { shown, hidden } = visible(section.lines, section.preview, full);
+            return (_jsxs("div", { className: "not-prose", children: [_jsx(DiffView, { hiddenLines: 0, lines: shown }), _jsx(ShowMore, { hidden: hidden, onShowAll: onShowAll })] }));
+        }
+        case "excerpt": {
+            const { shown, hidden } = visible(section.lines, section.preview, full);
+            return (_jsxs("div", { children: [_jsx("pre", { className: monoBlock, "data-parakeet-section": "excerpt", children: shown.map((line, index) => (_jsxs("span", { className: "block whitespace-pre", children: [line.number === undefined ? null : (_jsx("span", { className: "text-dim mr-sm inline-block w-8 select-none text-right", children: String(line.number) })), line.text] }, String(index)))) }), _jsx(ShowMore, { hidden: hidden, onShowAll: onShowAll })] }));
+        }
+        case "matches": {
+            const { shown, hidden } = visible(section.matches, section.preview, full);
+            return (_jsxs("div", { children: [_jsx("pre", { className: monoBlock, "data-parakeet-section": "matches", children: shown.map((match, index) => (_jsxs("span", { className: "block whitespace-pre", children: [match.location === "" ? null : (_jsx("span", { className: "text-info mr-sm", children: match.location })), match.text] }, String(index)))) }), _jsx(ShowMore, { hidden: hidden, onShowAll: onShowAll })] }));
+        }
+        case "command":
+        case "script": {
+            const { shown, hidden } = visible(section.lines, section.preview, full);
+            return (_jsxs("div", { children: [_jsx("pre", { className: monoBlock, "data-parakeet-section": section.kind, children: shown.map((line, index) => (_jsxs("span", { className: "block whitespace-pre", children: [section.kind === "command" && index === 0 ? (_jsx("span", { className: "text-dim select-none", children: "$ " })) : null, line] }, String(index)))) }), _jsx(ShowMore, { hidden: hidden, onShowAll: onShowAll })] }));
+        }
+        case "output": {
+            const { shown, hidden } = visible(section.lines, section.preview, full);
+            return (_jsxs("div", { children: [_jsx("pre", { className: monoBlock, "data-parakeet-section": "output", children: shown.map((line, index) => (_jsxs("span", { className: line.stream === "stderr"
+                                ? "block whitespace-pre text-error"
+                                : "block whitespace-pre", "data-stream": line.stream, children: [line.stream === "stderr" ? (_jsx("span", { className: "select-none", children: "\u258D" })) : null, line.text] }, String(index)))) }), _jsx(ShowMore, { hidden: hidden, onShowAll: onShowAll })] }));
+        }
+        case "text": {
+            const { shown, hidden } = visible(section.lines, section.preview, full);
+            return (_jsxs("div", { children: [_jsx(CodeBlock, { className: "overflow-hidden rounded-lg", content: shown.join("\n"), header: section.label, ...(section.language === undefined
+                            ? {}
+                            : { language: section.language }) }), _jsx(ShowMore, { hidden: hidden, onShowAll: onShowAll })] }));
+        }
+    }
+}
+function CallBody({ call, tool, disclosure, onToggle, }) {
+    const fullId = `${call.id}:full`;
+    const full = disclosureOpen(disclosure, fullId, false);
+    const showAll = () => {
+        onToggle(fullId, false);
+    };
+    return (_jsxs("div", { className: "space-y-1.5 py-1.5 pr-2", "data-parakeet-call-body": true, children: [call.error === undefined ? null : (_jsx("p", { className: "not-prose m-0 font-mono text-[11px] text-error", role: "alert", children: call.error })), call.sections.map((section, index) => (_jsx(SectionView, { full: full, onShowAll: showAll, section: section }, `${section.kind}:${String(index)}`))), tool?.result?.content
+                .filter((part) => part.type === "image")
+                .map((part, index) => (_jsx("img", { alt: "Tool result", className: "max-w-full", src: `data:${part.mimeType};base64,${part.data}`, style: { maxHeight: 400 } }, `${call.id}-image-${String(index)}`)))] }));
+}
+function CallRow({ call, tool, disclosureId, size, disclosure, onToggle, renderToolActions, }) {
+    const defaultOpen = toolCallDefaultOpen(call);
+    const open = disclosureOpen(disclosure, disclosureId, defaultOpen);
+    const running = call.status === "running";
+    return (_jsxs("div", { "data-parakeet-call": call.kind, "data-status": call.status, children: [_jsx(Disclosure, { leading: _jsx(Sigil, { name: toolKindSigils[call.kind], size: 16 }), onOpenChange: () => {
+                    onToggle(disclosureId, defaultOpen);
+                }, open: open, size: size, summary: _jsxs(_Fragment, { children: [_jsx("span", { className: "text-base-content", children: running ? call.activeVerb : call.verb }), " ", _jsx("span", { className: "font-mono", children: call.label })] }), tone: call.status === "error" ? "error" : "neutral", trailing: _jsxs(_Fragment, { children: [call.exitCode === undefined ? null : (_jsxs(Badge, { size: "sm", tone: "error", children: ["exit ", String(call.exitCode)] })), call.durationMs === undefined ? null : (_jsx("span", { children: formatToolDuration(call.durationMs) })), _jsx(Status, { motion: running ? "bounce" : "none", title: call.status === "unknown" ? "result unavailable" : call.status, tone: statusTone(call.status) })] }), children: _jsx(CallBody, { call: call, disclosure: disclosure, onToggle: onToggle, tool: tool }) }), call.status === "completed" && tool?.result !== undefined
+                ? renderToolActions?.(tool)
+                : null] }));
+}
+/** Recent finished calls, or a live group, with reader-owned disclosure. */
+export const ToolGroup = memo(function ToolGroup({ group, disclosure, onToggle, renderToolActions, }) {
+    const defaultOpen = toolGroupDefaultOpen(group);
+    const open = disclosureOpen(disclosure, group.id, defaultOpen);
+    const running = group.status === "running";
+    const active = group.active;
+    const single = group.calls.length === 1 ? group.calls[0] : undefined;
+    if (single !== undefined)
+        return (_jsx("div", { className: "px-1", children: _jsx(CallRow, { call: single, disclosure: disclosure, disclosureId: single.id, onToggle: onToggle, renderToolActions: renderToolActions, size: "row", tool: group.tools[0] }) }));
+    return (_jsxs("div", { className: "px-1", children: [_jsx(Disclosure, { className: "[&>.caps-disclosure-panel]:hidden", leading: _jsx(Sigil, { name: "list", size: 16 }), onOpenChange: () => {
+                    onToggle(group.id, defaultOpen);
+                }, open: open, summary: running && active !== undefined ? (_jsxs(_Fragment, { children: [_jsx("span", { className: "text-base-content", children: active.activeVerb }), " ", _jsx("span", { className: "font-mono", children: active.label }), " \u00B7", " ", String(group.calls.length), " ", group.calls.length === 1 ? "call" : "calls"] })) : (_jsxs("span", { className: "text-base-content", children: [group.summary, " \u00B7 ", String(group.calls.length), " ", group.calls.length === 1 ? "call" : "calls"] })), tone: group.status === "error" ? "error" : "neutral", trailing: _jsxs(_Fragment, { children: [group.failedCount > 0 ? (_jsxs("span", { className: "text-error", children: [String(group.failedCount), " failed"] })) : null, group.durationMs === undefined ? null : (_jsx("span", { children: formatToolDuration(group.durationMs) })), _jsx(Status, { motion: running ? "bounce" : "none", title: group.status === "unknown" ? "result unavailable" : group.status, tone: statusTone(group.status) })] }) }), visibleToolCalls(group, open).map((call) => (_jsx(CallRow, { call: call, disclosure: disclosure, disclosureId: call.id, onToggle: onToggle, renderToolActions: renderToolActions, size: "row", tool: group.tools.find((tool) => tool.id === call.id) }, call.id))), group.status === "completed" && group.calls.length > 3 ? (_jsx("button", { "aria-expanded": open, className: "btn btn-ghost btn-xs text-dim", onClick: () => {
+                    onToggle(group.id, defaultOpen);
+                }, type: "button", children: open ? "Show less" : `Show all ${String(group.calls.length)} calls` })) : null] }));
+});

package/dist/components/WaitingNotice.d.ts

@@ -0,0 +1,7 @@
+import { type SessionViewState } from "../core/session-view-state.js";
+/** A queued Session reports the executor fact; stopping a turn leaves its queue intact. */
+export declare function WaitingNotice({ waiting, }: Readonly<{
+    waiting: Extract<SessionViewState, {
+        kind: "queued";
+    }> | null;
+}>): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/WaitingNotice.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { queuedSessionLabel, } from "../core/session-view-state.js";
+/** A queued Session reports the executor fact; stopping a turn leaves its queue intact. */
+export function WaitingNotice({ waiting, }) {
+    if (waiting === null)
+        return null;
+    return (_jsx("div", { role: "status", className: "flex items-center justify-between gap-2 px-3 py-1.5 text-xs text-dim", "data-parakeet-waiting": "waiting", children: _jsx("span", { children: queuedSessionLabel(waiting) }) }));
+}

package/dist/components/avatar-presentation.d.ts

@@ -0,0 +1,23 @@
+import { type Avatar } from "@fungi.computer/sprite/avatar";
+import type { AvatarPresentation as SpriteAvatarPresentation } from "@fungi.computer/sprite";
+/**
+ * Sprite props for one avatar, independent of the live `activity` a composer
+ * drives moment to moment. Every avatar-aware Parakeet component builds its
+ * `<Sprite>` props through this one mapper, so a stored avatar and the
+ * pre-avatar seeded look reach the canvas the same way. Unlike the Sprite
+ * service's own `AvatarPresentation`, these are never optional: the mapper
+ * always resolves a complete avatar, stored or legacy.
+ */
+export type AvatarSpriteProps = {
+    readonly src: SpriteAvatarPresentation["src"];
+    readonly appearance: NonNullable<SpriteAvatarPresentation["appearance"]>;
+    readonly expression: NonNullable<SpriteAvatarPresentation["expression"]>;
+    readonly renderStyle: NonNullable<SpriteAvatarPresentation["renderStyle"]>;
+};
+/**
+ * Map a stored avatar (or `null`/`undefined`, meaning none is saved yet) to
+ * Sprite props. The fallback is `legacyAvatar(seed)`: the mushroom, in the
+ * same seeded cap colour Agents have always worn, so an existing Agent
+ * renders byte-identically to before avatars existed.
+ */
+export declare function avatarPresentation(avatar: Avatar | null | undefined, seed: string): AvatarSpriteProps;

package/dist/components/avatar-presentation.js

@@ -0,0 +1,16 @@
+import { legacyAvatar } from "@fungi.computer/sprite/avatar";
+/**
+ * Map a stored avatar (or `null`/`undefined`, meaning none is saved yet) to
+ * Sprite props. The fallback is `legacyAvatar(seed)`: the mushroom, in the
+ * same seeded cap colour Agents have always worn, so an existing Agent
+ * renders byte-identically to before avatars existed.
+ */
+export function avatarPresentation(avatar, seed) {
+    const resolved = avatar ?? legacyAvatar(seed);
+    return {
+        src: { local: resolved.character },
+        appearance: resolved.appearance,
+        expression: resolved.expression,
+        renderStyle: resolved.renderStyle,
+    };
+}

package/dist/components/sprite-service.d.ts

@@ -0,0 +1,2 @@
+/** The one Sprite service Parakeet's mascot components share. */
+export declare const shiitakeSprite: import("@fungi.computer/sprite").SpriteService;

package/dist/components/sprite-service.js

@@ -0,0 +1,9 @@
+import { createSprite } from "@fungi.computer/sprite";
+/** The one Sprite service Parakeet's mascot components share. */
+export const shiitakeSprite = createSprite({
+    characters: {
+        mushroom: async () => (await import("@fungi.computer/sprite-zdog/mushroom")).default,
+        cat: async () => (await import("@fungi.computer/sprite-zdog/cat")).default,
+        burger: async () => (await import("@fungi.computer/sprite-zdog/burger")).default,
+    },
+});

package/dist/components/still-frame-cache.d.ts

@@ -0,0 +1,16 @@
+import type { AvatarSpriteProps } from "./avatar-presentation.js";
+/** The still-frame cache key for one presentation at one pixel size. */
+export declare function stillFrameKey(presentation: AvatarSpriteProps, size: number, devicePixelRatio: number): string;
+/** The cached still frame for `key`, refreshing its recency, or `undefined`. */
+export declare function getStillFrame(key: string): string | undefined;
+/** Cache `value` (a data URL) for `key`, evicting the oldest entry past 128. */
+export declare function setStillFrame(key: string, value: string): void;
+/**
+ * Capture the idle frame of a just-rendered Sprite host as a still image, or
+ * `undefined` when the host has no live canvas yet (not ready) or the
+ * canvas export is denied because the canvas is tainted. Other export failures
+ * propagate with their cause.
+ */
+export declare function captureStillFrame(host: HTMLElement | null): string | undefined;
+/** Test-only: clears every cached still frame so tests do not leak between runs. */
+export declare function clearStillFrameCache(): void;

package/dist/components/still-frame-cache.js

@@ -0,0 +1,63 @@
+const MAX_ENTRIES = 128;
+/**
+ * Idle heads shown over and over (an Agent rail) do not need their own live
+ * canvas: once one instance of a descriptor has rendered, every other idle
+ * instance can show the same still frame. Keyed by the resolved presentation
+ * plus the pixel size it was drawn at, so a resize or a different size
+ * elsewhere never serves the wrong frame. An LRU of about 128 entries; the
+ * oldest is evicted once that is exceeded.
+ */
+const cache = new Map();
+/** The still-frame cache key for one presentation at one pixel size. */
+export function stillFrameKey(presentation, size, devicePixelRatio) {
+    return JSON.stringify([
+        presentation.src,
+        presentation.appearance,
+        presentation.expression,
+        presentation.renderStyle,
+        size,
+        devicePixelRatio,
+    ]);
+}
+/** The cached still frame for `key`, refreshing its recency, or `undefined`. */
+export function getStillFrame(key) {
+    const value = cache.get(key);
+    if (value === undefined)
+        return undefined;
+    cache.delete(key);
+    cache.set(key, value);
+    return value;
+}
+/** Cache `value` (a data URL) for `key`, evicting the oldest entry past 128. */
+export function setStillFrame(key, value) {
+    cache.delete(key);
+    cache.set(key, value);
+    if (cache.size <= MAX_ENTRIES)
+        return;
+    const oldestKey = cache.keys().next().value;
+    if (oldestKey !== undefined)
+        cache.delete(oldestKey);
+}
+/**
+ * Capture the idle frame of a just-rendered Sprite host as a still image, or
+ * `undefined` when the host has no live canvas yet (not ready) or the
+ * canvas export is denied because the canvas is tainted. Other export failures
+ * propagate with their cause.
+ */
+export function captureStillFrame(host) {
+    const canvas = host?.querySelector("canvas");
+    if (!canvas)
+        return undefined;
+    try {
+        return canvas.toDataURL("image/png");
+    }
+    catch (cause) {
+        if (cause instanceof DOMException && cause.name === "SecurityError")
+            return undefined;
+        throw new Error("Could not capture an avatar still frame", { cause });
+    }
+}
+/** Test-only: clears every cached still frame so tests do not leak between runs. */
+export function clearStillFrameCache() {
+    cache.clear();
+}

package/dist/conversation.d.ts

@@ -0,0 +1,164 @@
+import { type ParakeetAuthorOf } from "./core/author-labels.js";
+import { type PromptDelivery, type SessionContext, type SessionExtensionSlots, type SessionPendingPrompts } from "@fungi.computer/shiitake/client";
+import type { ClientEntryV1 } from "@fungi.computer/shiitake/client-entry";
+import { type ClientContribution } from "./core/client-contributions.js";
+import { type ParakeetInteractions } from "./commands/interactions.js";
+import type { WhistleExecutionOutcome } from "@fungi.computer/whistle";
+import { type ReactNode } from "react";
+import { type SessionViewState } from "./core/session-view-state.js";
+import type { ParakeetSession } from "./session.js";
+import type { TimelineItem } from "./store/types.js";
+/** Stable model identity presented by the current Session. */
+export type ParakeetModel = Readonly<{
+    /** Provider model identifier. */
+    model: string;
+    /** Provider identifier. */
+    provider: string;
+}>;
+/** Aggregate usage presented by the current Session timeline. */
+export type ParakeetUsage = Readonly<{
+    /** Accumulated provider cost. */
+    cost: number;
+    /** Accumulated token count. */
+    tokens: number;
+}>;
+/** Conversation activity presented by Parakeet. */
+export type ParakeetStatus = "connecting" | "cancelling" | "error" | "idle" | "queued" | "retrying" | "sending" | "streaming" | "thinking" | "disconnected";
+/** Owner activity with the connection states shown while observation opens. */
+export type ParakeetSessionViewState = SessionViewState | Readonly<{
+    /** Session observation is opening. */
+    kind: "connecting";
+}> | Readonly<{
+    /** Session observation is unavailable. */
+    kind: "disconnected";
+    /** Reason suitable for presentation. */
+    cause: string;
+}>;
+/** Health of the current Session observation. */
+export type ParakeetObservation = Readonly<{
+    /** Observation is opening. */
+    status: "connecting";
+}> | Readonly<{
+    /** Observation is current. */
+    status: "live";
+}> | Readonly<{
+    /** Observation failed and can be reopened. */
+    status: "unavailable";
+    /** Sanitized reason suitable for presentation. */
+    reason: string;
+}>;
+/** Stable history and replaceable work rendered by a conversation client. */
+export type TimelineController = Readonly<{
+    /** Durable-backed rows whose identity is stable across progress revisions. */
+    settled: readonly TimelineItem[];
+    /** Replaceable progress, queued, and optimistic rows. */
+    tail: readonly TimelineItem[];
+    /** Last actually rendered durable row for each loaded command. */
+    commandAnchors: ReadonlyMap<string, string>;
+    /** Current owner-admitted prompts, independent of the visible history page. */
+    queued: SessionPendingPrompts;
+    /** Whether more admitted prompts exist beyond this projection. */
+    pendingHasMore: boolean;
+    /** Whether older history remains, unloaded, before `settled[0]`. */
+    hasMoreHistory: boolean;
+    /** An older history page is currently loading. */
+    loadingOlderHistory: boolean;
+    /** Load the next older history page; a no-op while one is in flight. */
+    loadOlderHistory: () => void;
+    /** Whether a newer evicted page lies beyond the retained history window. */
+    hasNewerHistory: boolean;
+    /** Refetch the nearest newer page after browsing backward. */
+    loadNewerHistory: () => void;
+    /** Keep the currently read page visible while the live tail advances. */
+    pinVisibleHistory: () => void;
+    /** Return to the live page and release paged history. */
+    jumpToLatest: () => void;
+    /** Newest durable assistant model identity. */
+    model?: ParakeetModel | undefined;
+    /** Accumulated durable usage. */
+    usage?: ParakeetUsage | undefined;
+}>;
+/** Draft and prompt operations for the current conversation. */
+export type ComposerController = Readonly<{
+    /** Stop the current turn. Queued prompts keep draining; the draft is unchanged. */
+    cancel: () => Promise<void>;
+    /** Current local input. */
+    draft: string;
+    /** Typed reason the latest prompt did not complete. */
+    failure: "admission" | "failed" | "cancelled" | "interrupted" | undefined;
+    /** Current send could not enter the bounded local admission queue. */
+    admissionError: "queue_full" | undefined;
+    /** Retry the exact most recent failed prompt. */
+    retry: () => void;
+    /** Remove one failed local admission from this conversation. */
+    dismissFailed: (requestId: string) => void;
+    /** Submit the current draft with the requested delivery intent. */
+    send: (delivery?: PromptDelivery) => void;
+    /**
+     * Run a host command, such as Whistle slash dispatch, for the current draft.
+     * Parakeet clears the draft only when the command handled it without
+     * declining (a refused replacement keeps the text) and the draft was
+     * not edited while the command ran.
+     */
+    submitCommand: (run: (draft: string) => Promise<WhistleExecutionOutcome | undefined>) => Promise<WhistleExecutionOutcome | undefined>;
+    /** Replace the local input. */
+    setDraft: (value: string) => void;
+}>;
+/** Session activity, observation, and Agent-lifetime controls. */
+export type StatusController = Readonly<{
+    /** Owner-issued identity of the running or queued Session command. */
+    commandId: string | undefined;
+    /** Health of the shared Session observation. */
+    observation: ParakeetObservation;
+    /** Reopen the shared Session observation. */
+    reconnect: () => Promise<ParakeetReconnectOutcome>;
+    /** Current conversation activity. */
+    status: ParakeetStatus;
+    /** Owner state, or a typed client connection state when the owner is unreachable. */
+    viewState: ParakeetSessionViewState;
+    /** Context use as the Session's compaction measures it, once known. */
+    context: SessionContext | undefined;
+}>;
+/** Result of retrying the shared Session observation. */
+export type ParakeetReconnectOutcome = Readonly<{
+    /** No reconnect was needed. */
+    kind: "nothing_to_reconnect";
+    /** Existing observation state. */
+    state: "connected" | "connecting";
+}> | Readonly<{
+    /** Session observation reopened. */
+    kind: "reconnected";
+}> | Readonly<{
+    /** Reopening failed. */
+    kind: "failed";
+    /** Reason suitable for presentation. */
+    cause: string;
+}>;
+/** Own one renderer-neutral conversation scope over the existing query cache. */
+export declare function ParakeetProvider({ children, session, clients, interactionStore, authorOf, }: Readonly<{
+    children: ReactNode;
+    session: ParakeetSession;
+    clients?: readonly ClientEntryV1[] | undefined;
+    interactionStore?: ParakeetInteractions | undefined;
+    /**
+     * Read the author to show from a message's opaque host metadata. Absent,
+     * lines show no author.
+     */
+    authorOf?: ParakeetAuthorOf | undefined;
+}>): import("react/jsx-runtime").JSX.Element;
+/** Read stable history and replaceable live work. */
+export declare function useTimeline(): TimelineController;
+/** Read and mutate the current conversation draft and prompt. */
+export declare function useComposer(): ComposerController;
+/** Dismiss a failed prompt without subscribing the timeline to composer edits. */
+export declare function useDismissFailedPrompt(): (requestId: string) => void;
+/** The Session this conversation observes. */
+export declare function useParakeetSession(): ParakeetSession;
+/** Read the Session's extension slots, including advertised command catalogs. */
+export declare function useExtensionSlots(): SessionExtensionSlots;
+/** Read Session activity and operate its observation. */
+export declare function useStatus(): StatusController;
+/** Presentation admitted once from the selected Session's already observed slots. */
+export declare function useClientContributions(): readonly ClientContribution[];
+/** The selected Session's ordinary command interaction owner. */
+export declare function useParakeetInteractions(): ParakeetInteractions;