@fungi.computer/parakeet 0.4.0 → 0.6.0

package/dist/core/session-query.js

@@ -4,6 +4,7 @@ import { reportFailure } from "../lib/failure.js";
 const emptyProjection = Object.freeze({
     observation: "connecting",
     snapshot: undefined,
+    lastReplyAt: undefined,
     latestPrompt: undefined,
 });
 // A watch starts with a bounded page, but its update frames keep arriving for
@@ -60,7 +61,7 @@ async function* observeSession(session, signal) {
                 yield { kind: "snapshot", value: snapshot };
             }
             else {
-                yield { kind: "frame", value: frame };
+                yield { kind: "frame", value: frame, snapshot };
             }
         }
         throw new Error("Session watch ended; current activity is unavailable");
@@ -81,21 +82,21 @@ function reduceObservation(projection, observation) {
         return {
             observation: "live",
             snapshot: observation.value,
+            lastReplyAt: Date.now(),
             latestPrompt: latestPrompt(observation.value.messages, projection.latestPrompt),
         };
-    if (projection.snapshot === undefined)
-        return observation.value.kind === "reset"
-            ? {
-                observation: "live",
-                snapshot: observation.value.baseline,
-                latestPrompt: latestPrompt(observation.value.baseline.messages),
-            }
-            : projection;
-    const snapshot = applySessionFrame(projection.snapshot, observation.value);
+    // The generator owns frame application and always delivers its baseline
+    // first. The cache only reduces already-projected observations.
+    const snapshot = observation.snapshot;
     return {
         observation: "live",
         snapshot,
-        latestPrompt: latestPrompt(snapshot.messages, projection.latestPrompt),
+        lastReplyAt: Date.now(),
+        latestPrompt: observation.value.kind === "reset" ||
+            (observation.value.kind === "update" &&
+                observation.value.messages.some((message) => message.value.role === "user"))
+            ? latestPrompt(snapshot.messages, projection.latestPrompt)
+            : projection.latestPrompt,
     };
 }
 /** One shared TanStack observation keyed by Shiitake's logical Session address. */
@@ -119,6 +120,7 @@ export function seedSessionQuery(queryClient, session, snapshot) {
     queryClient.setQueryData(sessionQueryOptions(session).queryKey, {
         observation: "connecting",
         snapshot,
+        lastReplyAt: undefined,
         latestPrompt: latestPrompt(snapshot.messages),
     });
 }

package/dist/core/session-view-state.d.ts

@@ -56,10 +56,8 @@ export type SessionActivityStatus = "cancelling" | "idle" | "queued" | "retrying
 /** Decide a Session's view state from its activity, terminals and progress. */
 export declare function sessionViewState(facts: SessionViewFacts): SessionViewState;
 export declare function sameRunningWork(left: AgentRunningWork | null, right: AgentRunningWork | null): boolean;
-/** Explain a queued Session using its owner's executor fact. */
-export declare function queuedSessionLabel(state: Extract<SessionViewState, {
-    kind: "queued";
-}>): string;
+/** Activity only: queued messages belong in the transcript, never in this label. */
+export declare function sessionStateLabel(state: SessionViewState, waitingOnYou?: boolean): "thinking" | "streaming" | "running a tool" | "idle" | "waiting on you" | "failed";
 /** Whether two view states say the same thing, so a readout can stay stable. */
 export declare function sameSessionViewState(left: SessionViewState, right: SessionViewState): boolean;
 /** Coarse activity for a view state: what the composer gates on. */

package/dist/core/session-view-state.js

@@ -67,19 +67,37 @@ export function sameRunningWork(left, right) {
     if (left === null || right === null)
         return left === right;
     if (left.kind === "session" && right.kind === "session")
-        return (left.sessionId === right.sessionId && left.commandId === right.commandId);
+        return (left.sessionId === right.sessionId &&
+            left.commandId === right.commandId &&
+            left.title === right.title);
     if (left.kind === "host" && right.kind === "host")
         return left.lane === right.lane && left.jobId === right.jobId;
     return false;
 }
-/** Explain a queued Session using its owner's executor fact. */
-export function queuedSessionLabel(state) {
-    const work = state.runningWork;
-    if (work === null)
-        return "Queued for host";
-    return work.kind === "session"
-        ? `Waiting for Session ${collapsed(work.sessionId, 256)}`
-        : `Waiting for host job ${collapsed(work.lane, 256)} · ${collapsed(work.jobId, 256)}`;
+/** Activity only: queued messages belong in the transcript, never in this label. */
+export function sessionStateLabel(state, waitingOnYou = false) {
+    switch (state.kind) {
+        case "queued":
+            // Executor occupancy is the only Agent activity fact in a queued view.
+            // Its identity/title is not a state and must never become a status label.
+            return state.runningWork === null ? "idle" : "thinking";
+        case "thinking":
+        case "cancelling":
+        case "compacting":
+        case "retrying":
+            return "thinking";
+        case "responding":
+            return "streaming";
+        case "running_tool":
+            return "running a tool";
+        case "error":
+            return "failed";
+        case "idle":
+        case "waiting_for_you":
+            // A completed turn is idle; an actual attention/approval request is
+            // what makes the caller show "waiting on you".
+            return waitingOnYou ? "waiting on you" : "idle";
+    }
 }
 /** Whether two view states say the same thing, so a readout can stay stable. */
 export function sameSessionViewState(left, right) {

package/dist/core/tool-groups.d.ts

@@ -1,5 +1,8 @@
 import type { ProjectedItem, TimelineItem, ToolGroupItem, ToolItem } from "../store/types.js";
 import { type ToolCallView } from "./tool-view.js";
+import type { SessionToolOutput } from "@fungi.computer/shiitake/client";
+/** Overlay only running calls; settled rows and their lazy result views stay shared. */
+export declare function overlayToolOutput(items: readonly TimelineItem[], output: readonly SessionToolOutput[]): readonly TimelineItem[];
 /** Build one group from a non-empty run of consecutive calls. */
 export declare function toolGroup(tools: readonly [ToolItem, ...ToolItem[]]): ToolGroupItem;
 /**

package/dist/core/tool-groups.js

@@ -1,5 +1,41 @@
 import { assistantMessageVisible } from "./assistant-visibility.js";
-import { toolCallView } from "./tool-view.js";
+import { liveOutputLines, toolCallView, } from "./tool-view.js";
+/** Overlay only running calls; settled rows and their lazy result views stay shared. */
+export function overlayToolOutput(items, output) {
+    if (output.length === 0)
+        return items;
+    return items.map((item) => {
+        if (item.kind !== "tool_group")
+            return item;
+        const tools = item.tools.map((tool) => {
+            const slot = output.find((candidate) => candidate.toolCallId === tool.id);
+            if (tool.status !== "running" || slot === undefined)
+                return tool;
+            return {
+                ...tool,
+                live: {
+                    lines: liveOutputLines(slot.tail),
+                    droppedBytes: slot.droppedBytes,
+                    revision: slot.revision,
+                },
+            };
+        });
+        if (tools.every((tool, index) => tool === item.tools[index]))
+            return item;
+        const calls = item.calls.map((call, index) => {
+            const tool = tools[index];
+            return tool === undefined || tool === item.tools[index]
+                ? call
+                : toolCallView(tool);
+        });
+        return {
+            ...item,
+            tools,
+            calls,
+            active: calls.find((call) => call.id === item.active?.id),
+        };
+    });
+}
 const nouns = {
     code: ["ran", "script", "scripts"],
     command: ["ran", "command", "commands"],

package/dist/core/tool-view.d.ts

@@ -173,7 +173,13 @@ export type ToolCallView = Readonly<{
     error?: string | undefined;
     /** Expanded body sections, in display order. */
     sections: readonly ToolCallSection[];
+    /** Replaceable output while the call runs. */
+    live?: ToolItem["live"];
 }>;
+/** Neutral lines from a bounded live tail. */
+export declare function liveOutputLines(tail: string): readonly string[];
+/** Live output stays visible when folded, independent of result disclosure. */
+export declare function toolLiveLines(call: ToolCallView, open: boolean): readonly string[];
 /** Items shown before "more" for excerpts, matches, and output. */
 export declare const toolPreviewLineLimit = 12;
 /** Build the renderer-neutral view of one call. */

package/dist/core/tool-view.js

@@ -4,6 +4,7 @@ import { formatPatch, parsePatch, structuredPatch, } from "diff";
 import { z } from "zod";
 import stripAnsi from "strip-ansi";
 import { reportFailure } from "../lib/failure.js";
+import { sanitizeDisplayText } from "./display-text.js";
 /** Shared tool status meaning, used by the browser and native presentations. */
 export function toolStatusTone(status) {
     if (status === "error")
@@ -27,6 +28,37 @@ export const toolKindSigils = {
     /** Artwork for search results. */
     search: "search",
 };
+/** Neutral lines from a bounded live tail. */
+export function liveOutputLines(tail) {
+    if (tail === "")
+        return [];
+    // Replacement dominance counts decoded code points, not rendered graphemes.
+    const characters = Array.from(tail);
+    if (characters.filter((character) => character === "\ufffd").length >
+        characters.length / 2)
+        return [
+            `[binary output, ${String(new TextEncoder().encode(tail).byteLength)} bytes]`,
+        ];
+    return stripAnsi(tail)
+        .replace(/\r\n/gu, "\n")
+        .replace(/\n$/u, "")
+        .split("\n")
+        .map((line) => sanitizeDisplayText(line.slice(line.lastIndexOf("\r") + 1)));
+}
+/** Live output stays visible when folded, independent of result disclosure. */
+export function toolLiveLines(call, open) {
+    const live = call.live;
+    if (live === undefined)
+        return [];
+    if (!open)
+        return live.lines.slice(-6);
+    return [
+        ...(live.droppedBytes === 0
+            ? []
+            : [`… ${String(Math.ceil(live.droppedBytes / 1024))} KiB earlier`]),
+        ...live.lines,
+    ];
+}
 /** Items shown before "more" for excerpts, matches, and output. */
 export const toolPreviewLineLimit = 12;
 /** Diff lines shown before "more". */
@@ -600,6 +632,7 @@ export function toolCallView(item) {
         kind,
         label: target.label,
         name: item.name,
+        live: item.status === "running" ? item.live : undefined,
         paths: target.paths,
         get sections() {
             return getDetails().sections;

package/dist/core/use-timeline-item-key.d.ts

@@ -1,8 +1,7 @@
 import type { TimelineItem } from "../store/types.js";
 /**
- * The virtualizer's row-key callback. Text-only progress replaces tail items
- * but not their keys, so the callback keeps its identity, and the virtualizer
- * its measurements, until the settled history or the order or identity of the
- * tail rows changes. Settled rows are keyed from the settled list alone.
+ * The virtualizer's row-key callback. Progress replaces row payloads, including
+ * live overlays on settled calls, but not row keys. Keep the callback and its
+ * measurements until the order or identity of the combined rows changes.
  */
 export declare function useTimelineItemKey(settled: readonly TimelineItem[], tail: readonly TimelineItem[]): (index: number) => string | number;

package/dist/core/use-timeline-item-key.js

@@ -9,21 +9,15 @@ function sameKeys(a, b) {
     return a.length === b.length && a.every((key, index) => key === b[index]);
 }
 /**
- * The virtualizer's row-key callback. Text-only progress replaces tail items
- * but not their keys, so the callback keeps its identity, and the virtualizer
- * its measurements, until the settled history or the order or identity of the
- * tail rows changes. Settled rows are keyed from the settled list alone.
+ * The virtualizer's row-key callback. Progress replaces row payloads, including
+ * live overlays on settled calls, but not row keys. Keep the callback and its
+ * measurements until the order or identity of the combined rows changes.
  */
 export function useTimelineItemKey(settled, tail) {
-    const next = tail.map(rowKey);
+    const next = [...settled, ...tail].map(rowKey);
     const [previous, setPrevious] = useState(next);
-    const tailKeys = sameKeys(previous, next) ? previous : next;
-    if (tailKeys !== previous)
-        setPrevious(tailKeys);
-    return useCallback((index) => {
-        const item = settled[index];
-        if (item !== undefined)
-            return rowKey(item);
-        return tailKeys[index - settled.length] ?? index;
-    }, [settled, tailKeys]);
+    const keys = sameKeys(previous, next) ? previous : next;
+    if (keys !== previous)
+        setPrevious(keys);
+    return useCallback((index) => keys[index] ?? index, [keys]);
 }

package/dist/headless.d.ts

@@ -1,12 +1,13 @@
 export { formatModelIdentity, formatModelWithLevel, } from "./core/model-identity.js";
 export type { QueuedRecallState, QueuedRecallOutcome, } from "./core/queued-recall.js";
 export type { ParakeetDraftIdentity, ParakeetDraftStorage, } from "./core/draft-storage.js";
+export { sanitizeDisplayText } from "./core/display-text.js";
 export { formatContextUsage, formatTokenCount } from "./core/format-context.js";
 export { formatWhen, oneLine } from "./core/picker-text.js";
 export { providerChoices } from "./provider-choices.js";
-export { ParakeetProvider, useComposer, useClientContributions, useParakeetInteractions, useExtensionSlots, useParakeetSession, useStatus, useTimeline, type ComposerController, type ParakeetDraftCheckpoint, type ParakeetModel, type ParakeetObservation, type ParakeetReconnectOutcome, type ParakeetStatus, type ParakeetSessionViewState, type ParakeetUsage, type StatusController, type TimelineController, } from "./conversation.js";
-export { sessionViewState, queuedSessionLabel, sessionActivityStatus, type SessionActivityStatus, type SessionViewFacts, type SessionViewState as ParakeetOwnerViewState, } from "./core/session-view-state.js";
-export { mergeTerminals } from "./core/session-projection.js";
+export { ParakeetProvider, useComposer, useClientContributions, useParakeetInteractions, useExtensionSlots, useParakeetSession, useLastSessionReplyAt, useStatus, useTimeline, type ComposerController, type ParakeetDraftCheckpoint, type ParakeetModel, type ParakeetObservation, type ParakeetReconnectOutcome, type ParakeetStatus, type ParakeetSessionViewState, type ParakeetUsage, type StatusController, type TimelineController, } from "./conversation.js";
+export { sessionViewState, sessionStateLabel, sessionActivityStatus, type SessionActivityStatus, type SessionViewFacts, type SessionViewState as ParakeetOwnerViewState, } from "./core/session-view-state.js";
+export { applySessionFrame, mergeTerminals, } from "./core/session-projection.js";
 export { type SessionActivity, seedSessionQuery, sessionQueryOptions, subscribeSessionActivity, } from "./core/session-query.js";
 export { accountCommandDefinitions, contributeAccountCommands, loginRegistry, type AccountCommandOptions, type AccountOwner, type ProviderAccess, type ModelAccountContext, type LoginHost, type LoginMethod, type LoginMethodKind, type LoginPolicy, type LoginProvider, type LoginScope, } from "./account-commands.js";
 export { contributeModelCommands, sessionModelCommandDefinitions, type SessionModelChoice, type SessionModelCommandOptions, } from "./model-commands.js";
@@ -15,7 +16,7 @@ export { contributeSessionCommands, type ParakeetSessionCommandOptions, } from "
 export { completeSlash, fuzzyMatch, keyBindings, keyLabel, parseSlashDraft, slashRegistry, type FuzzyMatch, type KeyBindingRow, type SlashCommand, type SlashCommandItem, type SlashCompletion, type SlashParse, type SlashWordItem, } from "./commands/slash.js";
 export { composerHints, fitHints, formatHints, type ComposerHintContext, type ComposerKeys, type KeyHint, } from "./commands/hints.js";
 export { isCancelledOutcome, runSlashDraft, type SlashRuntime, } from "./commands/run.js";
-export { createParakeetInteractions, type ParakeetInteractions, type ParakeetInteractionState, type ParakeetNotice, type ParakeetOpenInteraction, type ParakeetToast, } from "./commands/interactions.js";
+export { createParakeetInteractions, type ParakeetInteractions, type ParakeetAwaiting, type ParakeetInteractionState, type ParakeetNotice, type ParakeetOpenInteraction, type ParakeetToast, } from "./commands/interactions.js";
 export { parakeetBuiltinCommands, type ParakeetBuiltinOptions, } from "./commands/builtins.js";
 export { advertisedCommands, type AdvertisedCatalogError, type AdvertisedCommands, } from "./commands/advertised.js";
 export { useSlashCommands, type ParakeetCommandRuntime, type SlashCommandController, type SlashCommandOptions, } from "./commands/use-slash-commands.js";
@@ -23,9 +24,13 @@ export type { ParakeetSession, ParakeetSessionCommand, ParakeetPromptResult, } f
 export type { AssistantMessageItem as ParakeetAssistantMessageItem, TimelineItem as ParakeetTimelineItem, ToolGroupItem as ParakeetToolGroupItem, ToolItem as ParakeetToolItem, UserMessageItem as ParakeetUserMessageItem, } from "./store/types.js";
 export type { ToolArguments as ParakeetToolArguments } from "./core/tool-contract.js";
 export { useMarkdown, type MarkdownBlock, type MarkdownInline, } from "./markdown.js";
-export { formatToolDuration, toolCallView, toolKindSigils, toolStatusTone, type ToolCallSection as ParakeetToolCallSection, type ToolCallView as ParakeetToolCallView, type ToolDiffFile as ParakeetToolDiffFile, type ToolDiffHunk as ParakeetToolDiffHunk, type ToolDiffLine as ParakeetToolDiffLine, type ToolDiffRow as ParakeetToolDiffRow, type ToolExcerptLine as ParakeetToolExcerptLine, type ToolKind as ParakeetToolKind, type ToolMatch as ParakeetToolMatch, type ToolOutputLine as ParakeetToolOutputLine, } from "./core/tool-view.js";
+export { formatToolDuration, toolCallView, toolKindSigils, toolLiveLines, toolStatusTone, type ToolCallSection as ParakeetToolCallSection, type ToolCallView as ParakeetToolCallView, type ToolDiffFile as ParakeetToolDiffFile, type ToolDiffHunk as ParakeetToolDiffHunk, type ToolDiffLine as ParakeetToolDiffLine, type ToolDiffRow as ParakeetToolDiffRow, type ToolExcerptLine as ParakeetToolExcerptLine, type ToolKind as ParakeetToolKind, type ToolMatch as ParakeetToolMatch, type ToolOutputLine as ParakeetToolOutputLine, } from "./core/tool-view.js";
 export { assistantMessageVisible } from "./core/assistant-visibility.js";
 export { disclosureOpen, initialToolDisclosure, toggleAllDisclosure, toggleDisclosure, toolCallDefaultOpen, toolGroupDefaultOpen, visibleToolCalls, type ToolDisclosureState, } from "./core/tool-groups.js";
 export { useClientActions } from "./client-contributions.js";
+export { awaitingQueue, awaitingTakeover, decisionView, decisionViewText, initialDecisionState, reduceDecision, type AwaitingItem, type AwaitingKind, type AwaitingQueue, type DecisionEffect, type DecisionIntent, type DecisionOutcome, type DecisionPhase, type DecisionPrompt, type DecisionRowView, type DecisionState, type DecisionView, } from "./core/awaiting-answer.js";
+export { useDecision, type DecisionController } from "./use-decision.js";
+export { useApprovalAwaiting } from "./use-approval-awaiting.js";
+export { approvalCardCopy, approvalRefusal, askApproval, type ApprovalAbandoned, type ApprovalAnswered, type ApprovalAnswerInput, type ApprovalAnswerResult, type ApprovalCard, type ApprovalContent, type ApprovalDecision, type ApprovalEntry, type ApprovalFacts, type ApprovalOutcome, type ApprovalRefused, type ApprovalReview, type ApprovalSource, } from "./core/approval-decision.js";
 export { placeClientTimeline, type PlacedClientCell, } from "./core/client-timeline.js";
 export type { ClientContribution } from "./core/client-contributions.js";

package/dist/headless.js

@@ -1,10 +1,11 @@
 export { formatModelIdentity, formatModelWithLevel, } from "./core/model-identity.js";
+export { sanitizeDisplayText } from "./core/display-text.js";
 export { formatContextUsage, formatTokenCount } from "./core/format-context.js";
 export { formatWhen, oneLine } from "./core/picker-text.js";
 export { providerChoices } from "./provider-choices.js";
-export { ParakeetProvider, useComposer, useClientContributions, useParakeetInteractions, useExtensionSlots, useParakeetSession, useStatus, useTimeline, } from "./conversation.js";
-export { sessionViewState, queuedSessionLabel, sessionActivityStatus, } from "./core/session-view-state.js";
-export { mergeTerminals } from "./core/session-projection.js";
+export { ParakeetProvider, useComposer, useClientContributions, useParakeetInteractions, useExtensionSlots, useParakeetSession, useLastSessionReplyAt, useStatus, useTimeline, } from "./conversation.js";
+export { sessionViewState, sessionStateLabel, sessionActivityStatus, } from "./core/session-view-state.js";
+export { applySessionFrame, mergeTerminals, } from "./core/session-projection.js";
 export { seedSessionQuery, sessionQueryOptions, subscribeSessionActivity, } from "./core/session-query.js";
 export { accountCommandDefinitions, contributeAccountCommands, loginRegistry, } from "./account-commands.js";
 export { contributeModelCommands, sessionModelCommandDefinitions, } from "./model-commands.js";
@@ -18,8 +19,12 @@ export { parakeetBuiltinCommands, } from "./commands/builtins.js";
 export { advertisedCommands, } from "./commands/advertised.js";
 export { useSlashCommands, } from "./commands/use-slash-commands.js";
 export { useMarkdown, } from "./markdown.js";
-export { formatToolDuration, toolCallView, toolKindSigils, toolStatusTone, } from "./core/tool-view.js";
+export { formatToolDuration, toolCallView, toolKindSigils, toolLiveLines, toolStatusTone, } from "./core/tool-view.js";
 export { assistantMessageVisible } from "./core/assistant-visibility.js";
 export { disclosureOpen, initialToolDisclosure, toggleAllDisclosure, toggleDisclosure, toolCallDefaultOpen, toolGroupDefaultOpen, visibleToolCalls, } from "./core/tool-groups.js";
 export { useClientActions } from "./client-contributions.js";
+export { awaitingQueue, awaitingTakeover, decisionView, decisionViewText, initialDecisionState, reduceDecision, } from "./core/awaiting-answer.js";
+export { useDecision } from "./use-decision.js";
+export { useApprovalAwaiting } from "./use-approval-awaiting.js";
+export { approvalCardCopy, approvalRefusal, askApproval, } from "./core/approval-decision.js";
 export { placeClientTimeline, } from "./core/client-timeline.js";

package/dist/index.d.ts

@@ -1,5 +1,8 @@
 export { ParakeetProvider, useComposer, useStatus, useTimeline, useMarkdown, disclosureOpen, formatToolDuration, formatModelIdentity, formatModelWithLevel, formatContextUsage, formatTokenCount, initialToolDisclosure, toggleAllDisclosure, toggleDisclosure, toolCallDefaultOpen, toolGroupDefaultOpen, visibleToolCalls, } from "./headless.js";
 export { Parakeet, ParakeetView } from "./parakeet.js";
+export { ComposerModelKey, type ComposerModelKeyProps, } from "./components/ComposerModelKey.js";
+export { composerSendState } from "./components/ComposerShell.js";
+export { ComposerShell, useComposerTextareaSize, type ComposerShellProps, type ComposerShellRow, } from "./components/ComposerShell.js";
 export type { ParakeetVisitor } from "./parakeet.js";
 export { InteractionPanel, type InteractionPanelProps, } from "./components/InteractionPanel.js";
 export type { QueuedRecallState, QueuedRecallOutcome, ParakeetAssistantMessageItem, ComposerController, ParakeetDraftCheckpoint, ParakeetDraftIdentity, ParakeetDraftStorage, ParakeetModel, ParakeetSession, ParakeetStatus, ParakeetTimelineItem, ParakeetToolArguments, ParakeetToolCallSection, ParakeetToolCallView, ParakeetToolDiffFile, ParakeetToolDiffHunk, ParakeetToolDiffLine, ParakeetToolDiffRow, ParakeetToolExcerptLine, ParakeetToolMatch, ParakeetToolOutputLine, ParakeetToolGroupItem, ParakeetToolItem, ParakeetToolKind, ToolDisclosureState, ParakeetUsage, ParakeetUserMessageItem, StatusController, TimelineController, MarkdownBlock, MarkdownInline, } from "./headless.js";

package/dist/index.js

@@ -1,4 +1,7 @@
 export { ParakeetProvider, useComposer, useStatus, useTimeline, useMarkdown, disclosureOpen, formatToolDuration, formatModelIdentity, formatModelWithLevel, formatContextUsage, formatTokenCount, initialToolDisclosure, toggleAllDisclosure, toggleDisclosure, toolCallDefaultOpen, toolGroupDefaultOpen, visibleToolCalls, } from "./headless.js";
 export { Parakeet, ParakeetView } from "./parakeet.js";
+export { ComposerModelKey, } from "./components/ComposerModelKey.js";
+export { composerSendState } from "./components/ComposerShell.js";
+export { ComposerShell, useComposerTextareaSize, } from "./components/ComposerShell.js";
 export { InteractionPanel, } from "./components/InteractionPanel.js";
 export * from "./agent-head.js";

package/dist/parakeet.d.ts

@@ -31,6 +31,8 @@ export type ParakeetProps = Readonly<{
     composerActionVariant?: "primary" | "outline" | undefined;
     /** Optional caller-owned actions for a completed tool result. */
     renderToolActions?: ((item: ToolItem) => ReactNode) | undefined;
+    /** Optional host claim: true hides this item's image parts from the tool body because the host shows them. */
+    claimsToolMedia?: ((item: ToolItem) => boolean) | undefined;
     /** Optional caller-owned attachment below a settled assistant reply. */
     renderAssistantAttachment?: ((text: string) => ReactNode) | undefined;
     /** Optional display text; attachments still receive the original reply. */
@@ -54,6 +56,8 @@ export type ParakeetViewProps = Readonly<{
     composerActionVariant?: "primary" | "outline" | undefined;
     /** Optional caller-owned actions for a completed tool result. */
     renderToolActions?: ((item: ToolItem) => ReactNode) | undefined;
+    /** Optional host claim: true hides this item's image parts from the tool body because the host shows them. */
+    claimsToolMedia?: ((item: ToolItem) => boolean) | undefined;
     /** Optional caller-owned attachment below a settled assistant reply. */
     renderAssistantAttachment?: ((text: string) => ReactNode) | undefined;
     /** Optional display text; attachments still receive the original reply. */
@@ -72,6 +76,6 @@ export type ParakeetViewProps = Readonly<{
     commands?: ParakeetCommandRuntime | undefined;
 }>;
 /** Render the retained conversation surface within one Parakeet provider. */
-export declare function ParakeetView({ disambiguateAuthors, visitor, composerActionVariant, empty, commands, renderToolActions, renderAssistantAttachment, formatAssistantText, onLink, onOpen, }: ParakeetViewProps): ReactElement;
+export declare function ParakeetView({ disambiguateAuthors, visitor, composerActionVariant, empty, commands, renderToolActions, claimsToolMedia, renderAssistantAttachment, formatAssistantText, onLink, onOpen, }: ParakeetViewProps): ReactElement;
 /** Standalone typed composer and exact-message timeline. */
-export declare function Parakeet({ authorOf, disambiguateAuthors, visitor, markdownPolicy, composerActionVariant, empty, session, clients, renderToolActions, renderAssistantAttachment, formatAssistantText, commands, onLink, onOpen, }: ParakeetProps): ReactElement;
+export declare function Parakeet({ authorOf, disambiguateAuthors, visitor, markdownPolicy, composerActionVariant, empty, session, clients, renderToolActions, claimsToolMedia, renderAssistantAttachment, formatAssistantText, commands, onLink, onOpen, }: ParakeetProps): ReactElement;

package/dist/parakeet.js

@@ -6,6 +6,7 @@ import { createWhistle } from "@fungi.computer/whistle";
 import { useVirtualizer } from "@tanstack/react-virtual";
 import { useCallback, useEffect, useMemo, useRef, useState, } from "react";
 import { ParakeetProvider, useComposer, useClientContributions, useDismissFailedPrompt, useStatus, useTimeline, } from "./conversation.js";
+import { awaitingTakeover } from "./core/awaiting-answer.js";
 import { initialToolDisclosure, toggleDisclosure } from "./core/tool-groups.js";
 import { authorDisplayNames, } from "./core/author-labels.js";
 import { useTimelineItemKey } from "./core/use-timeline-item-key.js";
@@ -14,12 +15,11 @@ import { ClientRows } from "./components/ClientRows.js";
 import { useClientActions } from "./client-contributions.js";
 import { placeClientTimeline } from "./core/client-timeline.js";
 import { InteractionPanel } from "./components/InteractionPanel.js";
-import { WaitingNotice } from "./components/WaitingNotice.js";
 import { useSlashCommands, } from "./commands/use-slash-commands.js";
 import { TimelineItem } from "./components/TimelineItem.js";
 import { MarkdownPolicyContext } from "./components/MarkdownRenderer.js";
 /** Render the retained conversation surface within one Parakeet provider. */
-export function ParakeetView({ disambiguateAuthors, visitor, composerActionVariant, empty, commands, renderToolActions, renderAssistantAttachment, formatAssistantText, onLink, onOpen, }) {
+export function ParakeetView({ disambiguateAuthors, visitor, composerActionVariant, empty, commands, renderToolActions, claimsToolMedia, renderAssistantAttachment, formatAssistantText, onLink, onOpen, }) {
     const textareaRef = useRef(null);
     const [ownCommands] = useState(() => createWhistle());
     const slash = useSlashCommands({
@@ -31,6 +31,9 @@ export function ParakeetView({ disambiguateAuthors, visitor, composerActionVaria
     });
     const clientActions = useClientActions(commands ?? ownCommands);
     const contributions = useClientContributions();
+    const { draft } = useComposer();
+    // The decision in the composer is not also a footer row.
+    const answering = awaitingTakeover(slash.awaiting, draft)?.key;
     const timelineController = useTimeline();
     const placed = useMemo(() => placeClientTimeline(contributions, timelineController.commandAnchors, timelineController.positionAnchors), [
         contributions,
@@ -43,7 +46,11 @@ export function ParakeetView({ disambiguateAuthors, visitor, composerActionVaria
                 : null;
             if (anchor instanceof HTMLAnchorElement && onLink?.(anchor.href))
                 event.preventDefault();
-        }, children: [_jsxs("div", { className: "flex h-full w-full flex-col border-r border-base-300", children: [_jsx(ConversationTimeline, { disambiguateAuthors: visitor === undefined && disambiguateAuthors === true, clientActions: clientActions, onOpen: onOpen, focusAfterJump: textareaRef, empty: empty, renderToolActions: renderToolActions, renderAssistantAttachment: renderAssistantAttachment, formatAssistantText: formatAssistantText }), contributions.some(({ value }) => value.panel.length > 0) ? (_jsx("section", { "aria-label": "Session extension controls", className: "w-full shrink-0 border-t border-base-300 bg-base-100", children: contributions.map(({ entryId, value }) => {
+        }, children: [_jsxs("div", { className: "flex h-full w-full flex-col border-r border-base-300", children: [_jsx(ConversationTimeline, { disambiguateAuthors: visitor === undefined && disambiguateAuthors === true, clientActions: clientActions, onOpen: onOpen, focusAfterJump: textareaRef, empty: empty, renderToolActions: renderToolActions, claimsToolMedia: claimsToolMedia, renderAssistantAttachment: renderAssistantAttachment, formatAssistantText: formatAssistantText }), contributions.some(({ entryId, value }) => value.panel.some((row) => JSON.stringify([entryId, row.id]) !== answering)) ? (_jsx("section", { "aria-label": "Session extension controls", className: "w-full shrink-0 border-t border-base-300 bg-base-100", children: contributions.map(({ entryId, value: contribution }) => {
+                            const value = {
+                                ...contribution,
+                                panel: contribution.panel.filter((row) => JSON.stringify([entryId, row.id]) !== answering),
+                            };
                             // An extension's retained-event notice and null-anchor rows
                             // join its own footer entry; one with no panel row here keeps
                             // none of this, rather than growing a section just to show it.
@@ -92,7 +99,7 @@ function ConversationInteraction({ slash, }) {
                 slash.store.close();
         }, children: _jsx(DialogContent, { className: "w-[min(32rem,calc(100vw-2rem))] rounded-box bg-base-100 p-md shadow-lg", keepMounted: false, children: open === undefined ? null : (_jsx(InteractionPanel, { host: open.host, onClose: slash.store.close }, open.key)) }) }));
 }
-function ConversationTimeline({ disambiguateAuthors, clientActions, onOpen, focusAfterJump, empty, renderToolActions, renderAssistantAttachment, formatAssistantText, }) {
+function ConversationTimeline({ disambiguateAuthors, clientActions, onOpen, focusAfterJump, empty, renderToolActions, claimsToolMedia, renderAssistantAttachment, formatAssistantText, }) {
     const dismissFailed = useDismissFailedPrompt();
     const timelineController = useTimeline();
     const cancelQueued = useCallback((commandId) => {
@@ -160,7 +167,7 @@ function ConversationTimeline({ disambiguateAuthors, clientActions, onOpen, focu
         timelineController.jumpToLatest();
         timeline.scrollToEnd({ behavior: "smooth" });
     }, [timeline, timelineController]);
-    return (_jsxs("div", { className: "prose relative min-h-0 flex-1", children: [_jsx("div", { "aria-live": "polite", "aria-atomic": "true", className: "sr-only", children: sessionReadout(sessionStatus.status, sessionStatus.viewState) }), sessionStatus.observation.status === "unavailable" ? (_jsxs("div", { className: "flex items-center justify-between gap-2 px-3 py-1 text-xs text-dim", role: "status", children: [_jsx("span", { children: sessionStatus.observation.reason }), _jsx("button", { className: "underline", onClick: () => void sessionStatus.reconnect(), type: "button", children: "Reconnect" })] })) : null, _jsx("div", { className: "h-full min-h-0 overflow-y-auto", "data-chat-scroller": true, ref: scrollerRef, onScroll: (event) => {
+    return (_jsxs("div", { className: "prose relative min-h-0 flex-1", children: [_jsx("div", { "aria-live": "polite", "aria-atomic": "true", className: "sr-only", children: sessionReadout(sessionStatus.status, sessionStatus.viewState) }), sessionStatus.observation.status === "unavailable" ? (_jsxs("div", { className: "flex items-center justify-between gap-2 px-3 py-1 text-xs text-dim", role: "status", children: [_jsx("span", { children: sessionStatus.observation.reason }), _jsx(Button, { variant: "outline", size: "xs", onClick: () => void sessionStatus.reconnect(), type: "button", children: "Reconnect" })] })) : null, _jsx("div", { className: "h-full min-h-0 overflow-y-auto", "data-chat-scroller": true, ref: scrollerRef, onScroll: (event) => {
                     const top = event.currentTarget.scrollTop;
                     if (previousScrollTop.current !== undefined &&
                         top < previousScrollTop.current)
@@ -209,24 +216,23 @@ function ConversationTimeline({ disambiguateAuthors, clientActions, onOpen, focu
                                                     item.author.name,
                                             },
                                         }
-                                        : item, onDismissFailed: dismissFailed, onCancelQueued: cancelQueued, cancellingQueued: timelineController.cancellingQueued, onToggleTool: toggleTool, renderToolActions: renderToolActions, renderAssistantAttachment: renderAssistantAttachment, formatAssistantText: formatAssistantText, toolDisclosure: toolDisclosure }), placed.after.get(item.id)?.map(({ entryId, cell }) => (_jsx(ClientRows, { entryId: entryId, rows: cell.rows, actions: clientActions, onOpen: onOpen }, `${entryId}:${cell.id}`)))] }, virtualItem.key));
+                                        : item, onDismissFailed: dismissFailed, onCancelQueued: cancelQueued, cancellingQueued: timelineController.cancellingQueued, onToggleTool: toggleTool, renderToolActions: renderToolActions, claimsToolMedia: claimsToolMedia, renderAssistantAttachment: renderAssistantAttachment, formatAssistantText: formatAssistantText, toolDisclosure: toolDisclosure }), placed.after.get(item.id)?.map(({ entryId, cell }) => (_jsx(ClientRows, { entryId: entryId, rows: cell.rows, actions: clientActions, onOpen: onOpen }, `${entryId}:${cell.id}`)))] }, virtualItem.key));
                     }) })) : before.length > 0 ? (before) : hasMoreHistory ? null : ((empty ?? (_jsx("div", { className: "flex h-full items-center justify-center text-center", children: _jsxs("div", { children: [_jsx("p", { className: "mb-1 text-xs text-base-content", children: "Ready" }), _jsx("p", { className: "text-[10px] text-dim", children: "What would you like to build?" })] }) })))) }), count > 0 ? (_jsx(ScrollToBottomBlob, { direction: "forward", unread: unread, focusAfterJump: focusAfterJump, onJump: jumpToBottom, scrollerRef: scrollerRef })) : null] }));
 }
-/** The owner's queued state and independently contributed waiting controls. */
+/** Independently contributed waiting controls; queued messages stay in the transcript. */
 function ConversationWaiting({ clientActions, }) {
     const { viewState } = useStatus();
     const contributions = useClientContributions();
     const extensionWaiting = viewState.kind === "idle"
         ? contributions.find(({ value }) => value.waiting !== null)
         : undefined;
-    const waiting = viewState.kind === "queued" ? viewState : null;
-    return (_jsxs(_Fragment, { children: [extensionWaiting?.value.waiting === undefined ||
-                extensionWaiting.value.waiting === null ? null : (_jsxs("div", { className: "flex items-center gap-2 px-3 text-xs", children: [_jsx("span", { children: extensionWaiting.value.waiting.summary }), _jsx(Button, { size: "xs", variant: "outline", disabled: !clientActions.enabled ||
-                            clientActions.state.get(extensionWaiting.value.waiting.cancel)
-                                ?.pending === true, onClick: () => {
-                            if (extensionWaiting.value.waiting !== null)
-                                void clientActions.execute(extensionWaiting.entryId, extensionWaiting.value.waiting.cancel, true);
-                        }, children: extensionWaiting.value.waiting.cancel.label })] })), _jsx(WaitingNotice, { waiting: waiting })] }));
+    return (_jsx(_Fragment, { children: extensionWaiting?.value.waiting === undefined ||
+            extensionWaiting.value.waiting === null ? null : (_jsxs("div", { className: "flex items-center gap-2 px-3 text-xs", children: [_jsx("span", { children: extensionWaiting.value.waiting.summary }), _jsx(Button, { size: "xs", variant: "outline", disabled: !clientActions.enabled ||
+                        clientActions.state.get(extensionWaiting.value.waiting.cancel)
+                            ?.pending === true, onClick: () => {
+                        if (extensionWaiting.value.waiting !== null)
+                            void clientActions.execute(extensionWaiting.entryId, extensionWaiting.value.waiting.cancel, true);
+                    }, children: extensionWaiting.value.waiting.cancel.label })] })) }));
 }
 function ConversationComposer({ visitor, textareaRef, composerActionVariant, slash, }) {
     const composer = useComposer();
@@ -242,6 +248,7 @@ function ConversationComposer({ visitor, textareaRef, composerActionVariant, sla
     }, [composer.cancel]);
     const composerProps = {
         queuedRecall: visitor === undefined ? composer : undefined,
+        onImagesChange: visitor === undefined ? composer.setImages : undefined,
         statusChips: contributions
             .flatMap(({ value }) => value.chips)
             .sort((left, right) => left.order - right.order)
@@ -270,6 +277,6 @@ function ConversationComposer({ visitor, textareaRef, composerActionVariant, sla
     return _jsx(ChatComposer, { ...composerProps });
 }
 /** Standalone typed composer and exact-message timeline. */
-export function Parakeet({ authorOf, disambiguateAuthors, visitor, markdownPolicy = "session", composerActionVariant, empty, session, clients, renderToolActions, renderAssistantAttachment, formatAssistantText, commands, onLink, onOpen, }) {
-    return (_jsx(MarkdownPolicyContext.Provider, { value: markdownPolicy, children: _jsx(ParakeetProvider, { session: session, clients: clients, authorOf: authorOf, children: _jsx(ParakeetView, { disambiguateAuthors: disambiguateAuthors, visitor: visitor, composerActionVariant: composerActionVariant, empty: empty, renderToolActions: renderToolActions, renderAssistantAttachment: renderAssistantAttachment, formatAssistantText: formatAssistantText, commands: commands, onLink: onLink, onOpen: onOpen }) }) }));
+export function Parakeet({ authorOf, disambiguateAuthors, visitor, markdownPolicy = "session", composerActionVariant, empty, session, clients, renderToolActions, claimsToolMedia, renderAssistantAttachment, formatAssistantText, commands, onLink, onOpen, }) {
+    return (_jsx(MarkdownPolicyContext.Provider, { value: markdownPolicy, children: _jsx(ParakeetProvider, { session: session, clients: clients, authorOf: authorOf, children: _jsx(ParakeetView, { disambiguateAuthors: disambiguateAuthors, visitor: visitor, composerActionVariant: composerActionVariant, empty: empty, renderToolActions: renderToolActions, claimsToolMedia: claimsToolMedia, renderAssistantAttachment: renderAssistantAttachment, formatAssistantText: formatAssistantText, commands: commands, onLink: onLink, onOpen: onOpen }) }) }));
 }

package/dist/store/types.d.ts

@@ -51,7 +51,7 @@ export type LocalPromptAdmission = Readonly<{
     /** Existing Session delivery intent. */
     delivery: PromptDelivery;
     /** Current local admission result. */
-    status: "admitting" | "accepted" | "failed";
+    status: "queued-local" | "admitting" | "accepted" | "failed";
     /** User-presentable admission error when status is failed. */
     error?: string;
 }>;
@@ -73,6 +73,10 @@ export type AssistantMessageItem = Readonly<{
     text: string;
     /** Pi's private failed-turn error text; never a terminal or delegation diagnostic. */
     providerError?: string;
+    /** Short assistant output retained before a provider failure, not provider prose. */
+    errorDetail?: string;
+    /** Consecutive failures with the same visible headline and detail. */
+    repeatCount?: number;
     /** Assistant reasoning text, when supplied by the model. */
     thinking?: string;
     /** Usage carried by the exact assistant message. */
@@ -101,6 +105,15 @@ export type ToolItem = Readonly<{
     startedAt?: number;
     /** Owner-confirmed activity or result; unknown when neither is available. */
     status: "completed" | "error" | "running" | "unknown";
+    /** Replaceable display-only output, never part of the durable result. */
+    live?: Readonly<{
+        /** Neutral output lines. */
+        lines: readonly string[];
+        /** Raw producer bytes omitted before this tail. */
+        droppedBytes: number;
+        /** Owner-issued output revision. */
+        revision: number;
+    }>;
 }>;
 /**
  * One maximal run of consecutive tool calls between conversation rows. A lone