parakeet

Import

Import

import * as api from "@fungi.computer/parakeet";

Exports

Kind	Export	Description
Ttype alias	AgentHeadActivity	What the head is doing: at rest, working something out, or talking.
Ttype alias	InteractionPanelProps	The interaction to draw and the page’s close callback.
Ttype alias	AvatarState	The current activity and expression supplied to a live avatar.
Ttype alias	ParakeetModel	Stable model identity presented by the current Session.
Ttype alias	ParakeetUsage	Aggregate usage presented by the current Session timeline.
Ttype alias	ParakeetStatus	Conversation activity presented by Parakeet.
Ttype alias	TimelineController	Stable history and replaceable work rendered by a conversation client.
Ttype alias	ParakeetDraftCheckpoint	A host may proceed with restart only after the current journal committed.
Ttype alias	ComposerController	Draft and prompt operations for the current conversation.
Ttype alias	StatusController	Session activity, observation, and Agent-lifetime controls.
Ttype alias	ParakeetAuthor	Who wrote a timeline line, as the host chose to show them.
Ttype alias	ParakeetAuthorOf	The host’s reading of a message’s opaque metadata: the author to show, or none. Parakeet never interprets metadata itself.
Ttype alias	ParakeetDraftIdentity	Durable owner identity, independent of the current service endpoint.
Ttype alias	ParakeetDraftStorage	Hosts must commit a replacement before returning, or throw without changing it.
Ttype alias	QueuedRecallState	Ephemeral composer reservation, never an admission journal or queue.
Ttype alias	QueuedRecallOutcome	Result of one recall gesture; an empty queue permits local input history.
Ttype alias	ParakeetToolArguments	Pi’s JSON argument object after the maintained Zod boundary parser.
Ttype alias	ToolDisclosureState	View-only open/closed state shared by the browser and terminal renderers.
Ttype alias	ParakeetToolKind	Closed presentation vocabulary for one tool call. It is chosen from the typed tool name, never inferred from arguments or result text.
Ttype alias	ParakeetToolDiffLine	One changed or context line of a diff hunk.
Ttype alias	ParakeetToolDiffHunk	One hunk: a jsdiff hunk, or one @@ block of a Codex patch.
Ttype alias	ParakeetToolDiffFile	The hunks for one file.
Ttype alias	ParakeetToolDiffRow	One display row of a diff, flattened once here so every renderer draws the same rows. File rows appear only when a call touches several files.
Ttype alias	ParakeetToolExcerptLine	One file excerpt line; the number is present only when it is known.
Ttype alias	ParakeetToolMatch	One search hit.
Ttype alias	ParakeetToolOutputLine	One line of command output, marked by the stream that produced it.
Ttype alias	ParakeetToolCallSection	One typed section of an expanded call body. Sections hold complete bounded content; renderers show preview items and offer the rest.
Ttype alias	ParakeetToolCallView	Renderer-neutral presentation of one tool call and its joined result.
Ttype alias	ParakeetVisitor	Public composer options for an anonymous visitor conversation.
Ttype alias	ParakeetProps	Props for the standalone retained conversation surface.
Ttype alias	ParakeetViewProps	Props for the reusable retained conversation view.
Ttype alias	ParakeetPromptResult	A prompt may be recorded for a human without admitting Agent work.
Ttype alias	ParakeetSessionCommand	Session commands preserve their owner results, including held visitor lines.
Ttype alias	ParakeetSession	The exact Shiitake operations consumed by the retained conversation UI.
Ttype alias	ParakeetUserMessageItem	One user prompt projected into the conversation timeline.
Ttype alias	ParakeetAssistantMessageItem	One assistant message projected from exact stored Pi content.
Ttype alias	ParakeetToolItem	One Pi tool call joined with its corresponding tool result.
Ttype alias	ParakeetToolGroupItem	One maximal run of consecutive tool calls between conversation rows. A lone call is a group of one. Grouping is computed once by the headless projection.
Ttype alias	ParakeetTimelineItem	Stable row grammar rendered by Parakeet’s timeline.
constconstant	AgentHead	An Agent’s head at avatar size, drawn from the Agent’s own avatar (a property of the Agent record, never of a conversation). The letter shows until a frame is ready. The live canvas stays mounted and is paused unless thinking or speaking, so an idle head shows its real look without animating.
constconstant	ShiitakeAvatar	A sprite head drawn in the live activity and expression it is given. With an avatar it draws that look (a member’s own, in their settings); with none it is Shiitake, the product mascot, in the character’s own defaults. Conversations have no avatar: an Agent’s head is AgentHead, drawn from the Agent record.
constconstant	initialToolDisclosure	Defaults only, with no reader choices.
fnfunction	InteractionPanel()	Browser renderer for one Whistle interaction. It draws the same host snapshot the terminal draws; the command, not the page, defines the steps.
fnfunction	ParakeetProvider()	Own one renderer-neutral conversation scope over the existing query cache.
fnfunction	useTimeline()	Read stable history and replaceable live work.
fnfunction	useComposer()	Read and mutate the current conversation draft and prompt.
fnfunction	useStatus()	Read Session activity and operate its observation.
fnfunction	formatTokenCount()	One token count, compacted for a narrow readout, e.g. 182000 to 182K. Shared by the context footer and the compaction divider and notices.
fnfunction	formatContextUsage()	Context used over the model’s window, e.g. 12K/200K, shared by the browser and terminal footers. An unknown window shows the tokens alone.
fnfunction	formatModelIdentity()	The durable assistant’s provider/model ids, shared by browser and terminal.
fnfunction	formatModelWithLevel()	The model identity with its thinking level, “provider/model (level)”; no level, no suffix.
fnfunction	toolGroupDefaultOpen()	Active and failed groups show every call; clean history retains a visible tail.
fnfunction	visibleToolCalls()	Even a folded group shows recent calls, rather than hiding all tool work.
fnfunction	toolCallDefaultOpen()	A failed call opens by default so its error is visible.
fnfunction	disclosureOpen()	Whether a group or call is currently open.
fnfunction	toggleDisclosure()	Flip one group or call, recording the reader’s explicit choice.
fnfunction	toggleAllDisclosure()	Expand everything, or collapse everything when the reader has expanded anything. Either way individual choices are cleared.
fnfunction	formatToolDuration()	Compact duration: 340ms, 1.2s, 2m 5s.
fnfunction	useMarkdown()	Parse chat Markdown for headless hosts, including terminal presentation.
fnfunction	ParakeetView()	Render the retained conversation surface within one Parakeet provider.
fnfunction	Parakeet()	Standalone typed composer and exact-message timeline.

AgentHeadActivityTtype alias

Signature

type AgentHeadActivity = "idle" | "thinking" | "speaking";

What the head is doing: at rest, working something out, or talking.

---

InteractionPanelPropsTtype alias

Signature

type InteractionPanelProps = Readonly<{
  host: WhistleInteractionHost;
  onClose?: () => void;
}>;

The interaction to draw and the page’s close callback.

---

AvatarStateTtype alias

Signature

type AvatarState = Readonly<
  Pick<AvatarPresentation, "activity" | "expression">
>;

The current activity and expression supplied to a live avatar.

---

ParakeetModelTtype alias

Signature

type ParakeetModel = Readonly<{
  model: string;
  provider: string;
}>;

Stable model identity presented by the current Session.

---

ParakeetUsageTtype alias

Signature

type ParakeetUsage = Readonly<{
  cost: number;
  tokens: number;
}>;

Aggregate usage presented by the current Session timeline.

---

ParakeetStatusTtype alias

Signature

type ParakeetStatus =
  | "connecting"
  | "cancelling"
  | "error"
  | "idle"
  | "queued"
  | "retrying"
  | "sending"
  | "streaming"
  | "thinking"
  | "disconnected";

Conversation activity presented by Parakeet.

---

TimelineControllerTtype alias

Signature

type TimelineController = Readonly<{
  cancelQueued: (commandId) => Promise<void>;
  cancellingQueued: boolean;
  settled: readonly ParakeetTimelineItem[];
  tail: readonly ParakeetTimelineItem[];
  positionAnchors: ReadonlyMap<number, string | null>;
  commandAnchors: ReadonlyMap<string, string>;
  queued: SessionPendingPrompts;
  pendingHasMore: boolean;
  hasMoreHistory: boolean;
  loadingOlderHistory: boolean;
  loadOlderHistory: () => void;
  hasNewerHistory: boolean;
  loadNewerHistory: () => void;
  pinVisibleHistory: () => void;
  jumpToLatest: () => void;
  model?: ParakeetModel;
  usage?: ParakeetUsage;
}>;

Stable history and replaceable work rendered by a conversation client.

---

ParakeetDraftCheckpointTtype alias

Signature

type ParakeetDraftCheckpoint =
  | Readonly<{
      status: "saved";
    }>
  | Readonly<{
      status: "failed";
      reason: string;
    }>;

A host may proceed with restart only after the current journal committed.

---

ComposerControllerTtype alias

Signature

type ComposerController = Readonly<{
  cancel: () => Promise<void>;
  draft: string;
  images: PromptCommand["images"];
  recallState: QueuedRecallState;
  recall: () => Promise<QueuedRecallOutcome>;
  checkpointDraft: () => ParakeetDraftCheckpoint;
  failure: "admission" | "failed" | "cancelled" | "interrupted" | undefined;
  admissionError: "offline_queue_full" | "queue_full" | undefined;
  retry: () => void;
  dismissFailed: (requestId) => void;
  send: (delivery?) => void;
  submitCommand: (run) => Promise<WhistleExecutionOutcome | undefined>;
  setDraft: (value) => void;
  setImages: (images) => void;
}>;

Draft and prompt operations for the current conversation.

---

StatusControllerTtype alias

Signature

type StatusController = Readonly<{
  commandId: string | undefined;
  observation: ParakeetObservation;
  reconnect: () => Promise<ParakeetReconnectOutcome>;
  status: ParakeetStatus;
  viewState: ParakeetSessionViewState;
  context: SessionContext | undefined;
}>;

Session activity, observation, and Agent-lifetime controls.

---

ParakeetAuthorTtype alias

Signature

type ParakeetAuthor = Readonly<{
  id: string;
  name: string;
  kind?: "agent";
}>;

Who wrote a timeline line, as the host chose to show them.

---

ParakeetAuthorOfTtype alias

Signature

type ParakeetAuthorOf = (meta) => ParakeetAuthor | undefined;

The host’s reading of a message’s opaque metadata: the author to show, or none. Parakeet never interprets metadata itself.

Parameters

Parameter	Type
meta	SessionMessage["meta"]

Returns

ParakeetAuthor | undefined

---

ParakeetDraftIdentityTtype alias

Signature

type ParakeetDraftIdentity = Readonly<{
  agentId: string;
  sessionId: string;
}>;

Durable owner identity, independent of the current service endpoint.

---

ParakeetDraftStorageTtype alias

Signature

type ParakeetDraftStorage = Readonly<{
  getItem: (key) => string | null;
  setItem: (key, value) => void;
}>;

Hosts must commit a replacement before returning, or throw without changing it.

---

QueuedRecallStateTtype alias

Signature

type QueuedRecallState =
  | Readonly<{
      kind: "idle" | "recalling" | "restored";
    }>
  | Readonly<{
      kind: "too_late" | "uncertain";
      message: string;
    }>;

Ephemeral composer reservation, never an admission journal or queue.

---

QueuedRecallOutcomeTtype alias

Signature

type QueuedRecallOutcome =
  "ignored" | "empty" | "restored" | "too_late" | "uncertain";

Result of one recall gesture; an empty queue permits local input history.

---

ParakeetToolArgumentsTtype alias

Signature

type ParakeetToolArguments = JsonObject;

Pi’s JSON argument object after the maintained Zod boundary parser.

---

ToolDisclosureStateTtype alias

Signature

type ToolDisclosureState = Readonly<{
  mode: "collapsed" | "default" | "expanded";
  overrides: ReadonlyMap<string, boolean>;
}>;

View-only open/closed state shared by the browser and terminal renderers.

---

ParakeetToolKindTtype alias

Signature

type ParakeetToolKind =
  "code" | "command" | "edit" | "other" | "read" | "search";

Closed presentation vocabulary for one tool call. It is chosen from the typed tool name, never inferred from arguments or result text.

---

ParakeetToolDiffLineTtype alias

Signature

type ParakeetToolDiffLine = Readonly<{
  kind: "add" | "context" | "remove";
  text: string;
}>;

One changed or context line of a diff hunk.

---

ParakeetToolDiffHunkTtype alias

Signature

type ParakeetToolDiffHunk = Readonly<{
  header?: string;
  lines: readonly ParakeetToolDiffLine[];
}>;

One hunk: a jsdiff hunk, or one @@ block of a Codex patch.

---

ParakeetToolDiffFileTtype alias

Signature

type ParakeetToolDiffFile = Readonly<{
  operation: "add" | "delete" | "update";
  path?: string;
  moveTo?: string;
  hunks: readonly ParakeetToolDiffHunk[];
  unified: string;
  lineNumbers: boolean;
}>;

The hunks for one file.

---

ParakeetToolDiffRowTtype alias

Signature

type ParakeetToolDiffRow = Readonly<{
  kind: "add" | "context" | "file" | "hunk" | "remove";
  text: string;
}>;

One display row of a diff, flattened once here so every renderer draws the same rows. File rows appear only when a call touches several files.

---

ParakeetToolExcerptLineTtype alias

Signature

type ParakeetToolExcerptLine = Readonly<{
  number?: number;
  text: string;
}>;

One file excerpt line; the number is present only when it is known.

---

ParakeetToolMatchTtype alias

Signature

type ParakeetToolMatch = Readonly<{
  location: string;
  text: string;
}>;

One search hit.

---

ParakeetToolOutputLineTtype alias

Signature

type ParakeetToolOutputLine = Readonly<{
  stream: "stderr" | "stdout";
  text: string;
}>;

One line of command output, marked by the stream that produced it.

---

ParakeetToolCallSectionTtype alias

Signature

type ParakeetToolCallSection = Readonly<
  | {
      kind: "excerpt";
      lines: readonly ParakeetToolExcerptLine[];
      preview: number;
    }
  | {
      kind: "matches";
      matches: readonly ParakeetToolMatch[];
      preview: number;
    }
  | {
      kind: "diff";
      files: readonly ParakeetToolDiffFile[];
      lines: readonly ParakeetToolDiffRow[];
      preview: number;
    }
  | {
      kind: "command";
      lines: readonly string[];
      preview: number;
    }
  | {
      kind: "script";
      lines: readonly string[];
      preview: number;
    }
  | {
      kind: "output";
      lines: readonly ParakeetToolOutputLine[];
      preview: number;
    }
  | {
      kind: "text";
      label?: string;
      language?: "json";
      lines: readonly string[];
      preview: number;
    }
>;

One typed section of an expanded call body. Sections hold complete bounded content; renderers show preview items and offer the rest.

---

ParakeetToolCallViewTtype alias

Signature

type ParakeetToolCallView = Readonly<{
  id: string;
  kind: ParakeetToolKind;
  name: string;
  verb: string;
  activeVerb: string;
  label: string;
  paths: readonly string[];
  status: ParakeetToolItem["status"];
  durationMs?: number;
  exitCode?: number;
  error?: string;
  sections: readonly ParakeetToolCallSection[];
}>;

Renderer-neutral presentation of one tool call and its joined result.

---

ParakeetVisitorTtype alias

Signature

type ParakeetVisitor = Readonly<{
  agentName: string;
}>;

Public composer options for an anonymous visitor conversation.

---

ParakeetPropsTtype alias

Signature

type ParakeetProps = Readonly<{
  disambiguateAuthors?: boolean;
  authorOf?: ParakeetAuthorOf;
  visitor?: ParakeetVisitor;
  markdownPolicy?: "session" | "visitor";
  session: ParakeetSession;
  clients?: readonly ClientEntryV1[];
  composerActionVariant?: "primary" | "outline";
  renderToolActions?: (item) => ReactNode;
  claimsToolMedia?: (item) => boolean;
  renderAssistantAttachment?: (text) => ReactNode;
  formatAssistantText?: (text) => string;
  onLink?: (href) => boolean;
  onOpen?: (target) => void;
  empty?: ReactNode;
  commands?: ParakeetCommandRuntime;
}>;

Props for the standalone retained conversation surface.

---

ParakeetViewPropsTtype alias

Signature

type ParakeetViewProps = Readonly<{
  disambiguateAuthors?: boolean;
  visitor?: ParakeetVisitor;
  composerActionVariant?: "primary" | "outline";
  renderToolActions?: (item) => ReactNode;
  claimsToolMedia?: (item) => boolean;
  renderAssistantAttachment?: (text) => ReactNode;
  formatAssistantText?: (text) => string;
  onLink?: (href) => boolean;
  onOpen?: (target) => void;
  empty?: ReactNode;
  commands?: ParakeetCommandRuntime;
}>;

Props for the reusable retained conversation view.

---

ParakeetPromptResultTtype alias

Signature

type ParakeetPromptResult =
  | Accepted
  | Readonly<{
      status: "recorded";
    }>;

A prompt may be recorded for a human without admitting Agent work.

---

ParakeetSessionCommandTtype alias

Signature

type ParakeetSessionCommand = {
  (input): Promise<ParakeetPromptResult>;
  (input): Promise<CancelResult>;
  (input): Promise<undefined>;
  (input): Promise<
    Readonly<{
      sessionId: string;
    }>
  >;
  (input): Promise<
    | Readonly<{
        status: "accepted";
        commandId: string;
        sessionId?: string;
      }>
    | Readonly<{
        status: "recorded";
      }>
    | Readonly<{
        status: "too_late";
        commandId: string;
      }>
    | Readonly<{
        status: "unknown";
      }>
    | Readonly<{
        sessionId: string;
      }>
    | undefined
  >;
};

Session commands preserve their owner results, including held visitor lines.

Call Signature

Signature

(input): Promise<ParakeetPromptResult>;

Admit Agent work or record a prompt held for a human reply.

Parameters

Parameter	Type
input	| { delivery: Schema.Literals<readonly ["steer", "followUp"]>; requestId: Schema.String; type: Schema.Literal<"prompt">; text: Schema.String; images?: Schema.optionalKey<Schema.$Array<Schema.Struct<{ type: Schema.Literal<"image">; data: Schema.String; mimeType: Schema.String; }>>>; } | { type: Schema.Literal<"compact">; requestId: Schema.String; instructions?: Schema.optionalKey<Schema.String>; }

Returns

Promise<ParakeetPromptResult>

Call Signature

Signature

(input): Promise<CancelResult>;

Cancel the named queued or running command.

Parameters

Parameter	Type
input	{ commandId: Schema.String; onlyIfPending?: Schema.optional<Schema.Boolean>; type: Schema.Literal<"cancel">; }
input.commandId	Schema.String
input.onlyIfPending?	Schema.optional<Schema.Boolean>
input.type	Schema.Literal<"cancel">

Returns

Promise<CancelResult>

Call Signature

Signature

(input): Promise<undefined>;

Forward an owner-supported Session control command.

Parameters

Parameter	Type
input	| { type: Schema.Literal<"branch">; entryId: Schema.String; } | { type: Schema.Literal<"operator">; requestId: Schema.String; author: Schema.Literals<readonly ["operator", "party"]>; text: Schema.String; } | { type: Schema.Literal<"title">; title: Schema.NullOr<Schema.String>; } | { type: Schema.Literal<"abort">; }

Returns

Promise<undefined>

Call Signature

Signature

(input): Promise<Readonly<{
  sessionId: string;
}>>;

Return the owner-issued address of a forked Session.

Parameters

Parameter	Type
input	{ type: Schema.Literal<"fork">; entryId: Schema.String; }
input.type	Schema.Literal<"fork">
input.entryId	Schema.String

Returns

Promise<Readonly<{ sessionId: string; }>>

Call Signature

Signature

(input): Promise<
  | Readonly<{
  status: "accepted";
  commandId: string;
  sessionId?: string;
}>
  | Readonly<{
  status: "recorded";
}>
  | Readonly<{
  status: "too_late";
  commandId: string;
}>
  | Readonly<{
  status: "unknown";
}>
  | Readonly<{
  sessionId: string;
}>
| undefined>;

Dispatch a typed command without inventing an admission result.

Parameters

Parameter

Type

input

| { delivery: Schema.Literals<readonly ["steer", "followUp"]>; requestId: Schema.String; type: Schema.Literal<"prompt">; text: Schema.String; images?: Schema.optionalKey<Schema.$Array<Schema.Struct<{ type: Schema.Literal<"image">; data: Schema.String; mimeType: Schema.String; }>>>; } | { type: Schema.Literal<"abort">; } | { commandId: Schema.String; onlyIfPending?: Schema.optional<Schema.Boolean>; type: Schema.Literal<"cancel">; } | { type: Schema.Literal<"branch">; entryId: Schema.String; } | { type: Schema.Literal<"fork">; entryId: Schema.String; } | { type: Schema.Literal<"operator">; requestId: Schema.String; author: Schema.Literals<readonly ["operator", "party"]>; text: Schema.String; } | { type: Schema.Literal<"compact">; requestId: Schema.String; instructions?: Schema.optionalKey<Schema.String>; } | { type: Schema.Literal<"title">; title: Schema.NullOr<Schema.String>; }

Returns

Promise< | Readonly<{ status: "accepted"; commandId: string; sessionId?: string; }> | Readonly<{ status: "recorded"; }> | Readonly<{ status: "too_late"; commandId: string; }> | Readonly<{ status: "unknown"; }> | Readonly<{ sessionId: string; }> | undefined>

---

ParakeetSessionTtype alias

Signature

type ParakeetSession = Readonly<
  Pick<
    ShiitakeSession,
    "address" | "extension" | "read" | "watch" | "withdraw" | "latestPending"
  > &
    object
>;

The exact Shiitake operations consumed by the retained conversation UI.

---

ParakeetUserMessageItemTtype alias

Signature

type ParakeetUserMessageItem = Readonly<{
  author?: ParakeetAuthor;
  origin?: SessionMessage["origin"];
  id: string;
  kind: "user_message";
  requestId?: string;
  commandId?: string;
  status: "pending" | "accepted" | "queued" | "failed" | "confirmed";
  delivery?: PromptDelivery;
  error?: string;
  at?: number;
  text: string;
}>;

One user prompt projected into the conversation timeline.

---

ParakeetAssistantMessageItemTtype alias

Signature

type ParakeetAssistantMessageItem = Readonly<{
  author?: ParakeetAuthor;
  id: string;
  kind: "assistant_message";
  isError?: boolean;
  pending: boolean;
  at?: number;
  text: string;
  providerError?: string;
  errorDetail?: string;
  repeatCount?: number;
  thinking?: string;
  usage?: Readonly<{
    cost: number;
    tokens: number;
  }>;
}>;

One assistant message projected from exact stored Pi content.

---

ParakeetToolItemTtype alias

Signature

type ParakeetToolItem = Readonly<{
  args: Readonly<ParakeetToolArguments>;
  id: string;
  kind: "tool";
  name: string;
  result?: ToolResultMessage;
  data?: SessionMessage["data"];
  startedAt?: number;
  status: "completed" | "error" | "running" | "unknown";
}>;

One Pi tool call joined with its corresponding tool result.

---

ParakeetToolGroupItemTtype alias

Signature

type ParakeetToolGroupItem = Readonly<{
  active?: ParakeetToolCallView;
  calls: readonly ParakeetToolCallView[];
  durationMs?: number;
  failedCount: number;
  id: string;
  kind: "tool_group";
  status: "completed" | "error" | "running" | "unknown";
  summary: string;
  tools: readonly ParakeetToolItem[];
}>;

One maximal run of consecutive tool calls between conversation rows. A lone call is a group of one. Grouping is computed once by the headless projection.

---

ParakeetTimelineItemTtype alias

Signature

type ParakeetTimelineItem =
  | ParakeetAssistantMessageItem
  | {
      id: string;
      kind: "compaction_divider";
      at: number;
      tokensBefore: number;
      tokensAfter: number | null;
    }
  | {
      id: string;
      kind: "compaction_notice";
      at: number;
      trigger: SessionCompactionTrigger;
      result: "failed" | "nothing_to_compact" | "stale" | "insufficient";
      diagnostic: string | null;
    }
  | ParakeetToolGroupItem
  | ParakeetUserMessageItem;

Stable row grammar rendered by Parakeet’s timeline.

Union Members

ParakeetAssistantMessageItem

---

Type Literal

Signature

{
  id: string;
  kind: "compaction_divider";
  at: number;
  tokensBefore: number;
  tokensAfter: number | null;
}

Name	Type	Description
id	string	Stable rendered-item identity, from the durable compaction entry.
kind	"compaction_divider"	Compaction-divider timeline discriminator.
at	number	When the compaction ran, in milliseconds since the epoch.
tokensBefore	number	Estimated context tokens the compaction started from.
tokensAfter	number | null	Estimated context tokens right after it; null for older compactions.

---

Type Literal

Signature

{
  id: string;
  kind: "compaction_notice";
  at: number;
  trigger: SessionCompactionTrigger;
  result: "failed" | "nothing_to_compact" | "stale" | "insufficient";
  diagnostic: string | null;
}

Name	Type	Description
id	string	Stable rendered-item identity, from the durable notice entry.
kind	"compaction_notice"	Compaction-notice timeline discriminator.
at	number	When it was recorded, in milliseconds since the epoch.
trigger	SessionCompactionTrigger	What started it: the user, the context threshold, or an overflow.
result	"failed" | "nothing_to_compact" | "stale" | "insufficient"	What the compaction did: nothing to summarize, a failure, or a summary dropped because its head no longer fit the context (stale) or because placing it would have left the context over the limit (insufficient).
diagnostic	string | null	A failure’s bounded reason; null otherwise.

---

ParakeetToolGroupItem

---

ParakeetUserMessageItem

AgentHeadconstconstant

Signature

const AgentHead: NamedExoticComponent<{
  timeMs?: number;
  activity?: AgentHeadActivity;
  avatar: {
    v: 1;
    character: "mushroom" | "cat" | "burger";
    appearance: z.ZodRecord<
      z.ZodString,
      z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>
    >;
    expression: string;
    renderStyle:
      | "plain"
      | "pencil"
      | "manga"
      | "riso"
      | "halftone"
      | "blueprint"
      | "crt"
      | "watercolor";
  };
  className?: string;
  name: string;
  size?: number;
}>;

An Agent’s head at avatar size, drawn from the Agent’s own avatar (a property of the Agent record, never of a conversation). The letter shows until a frame is ready. The live canvas stays mounted and is paused unless thinking or speaking, so an idle head shows its real look without animating.

---

ShiitakeAvatarconstconstant

Signature

const ShiitakeAvatar: NamedExoticComponent<{
  avatar?: {
    v: 1;
    character: "mushroom" | "cat" | "burger";
    appearance: z.ZodRecord<
      z.ZodString,
      z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>
    >;
    expression: string;
    renderStyle:
      | "plain"
      | "pencil"
      | "manga"
      | "riso"
      | "halftone"
      | "blueprint"
      | "crt"
      | "watercolor";
  } | null;
  className?: string;
  service?: SpriteService;
  state: AvatarState;
}>;

A sprite head drawn in the live activity and expression it is given. With an avatar it draws that look (a member’s own, in their settings); with none it is Shiitake, the product mascot, in the character’s own defaults. Conversations have no avatar: an Agent’s head is AgentHead, drawn from the Agent record.

---

initialToolDisclosureconstconstant

Signature

const initialToolDisclosure: ToolDisclosureState;

Defaults only, with no reader choices.

InteractionPanel()fnfunction

Signature

function InteractionPanel(__namedParameters): Element;

Browser renderer for one Whistle interaction. It draws the same host snapshot the terminal draws; the command, not the page, defines the steps.

Parameters

Parameter	Type
__namedParameters	InteractionPanelProps

Returns

Element

---

ParakeetProvider()fnfunction

Signature

function ParakeetProvider(__namedParameters): Element;

Own one renderer-neutral conversation scope over the existing query cache.

Parameters

Parameter	Type
__namedParameters	Readonly<{ children: ReactNode; session: ParakeetSession; clients?: readonly ClientEntryV1[]; interactionStore?: ParakeetInteractions; onToast?: (toast) => void; draftStorage?: ParakeetDraftStorage; draftIdentity?: ParakeetDraftIdentity; authorOf?: ParakeetAuthorOf; }>

Returns

Element

---

useTimeline()fnfunction

Signature

function useTimeline(): TimelineController;

Read stable history and replaceable live work.

Returns

TimelineController

---

useComposer()fnfunction

Signature

function useComposer(): ComposerController;

Read and mutate the current conversation draft and prompt.

Returns

ComposerController

---

useStatus()fnfunction

Signature

function useStatus(): StatusController;

Read Session activity and operate its observation.

Returns

StatusController

---

formatTokenCount()fnfunction

Signature

function formatTokenCount(tokens): string;

One token count, compacted for a narrow readout, e.g. 182000 to 182K. Shared by the context footer and the compaction divider and notices.

Parameters

Parameter	Type
tokens	number

Returns

string

---

formatContextUsage()fnfunction

Signature

function formatContextUsage(context): string;

Context used over the model’s window, e.g. 12K/200K, shared by the browser and terminal footers. An unknown window shows the tokens alone.

Parameters

Parameter	Type
context	SessionContext

Returns

string

---

formatModelIdentity()fnfunction

Signature

function formatModelIdentity(model): string;

The durable assistant’s provider/model ids, shared by browser and terminal.

Parameters

Parameter	Type
model	ParakeetModel

Returns

string

---

formatModelWithLevel()fnfunction

Signature

function formatModelWithLevel(model, level): string;

The model identity with its thinking level, “provider/model (level)”; no level, no suffix.

Parameters

Parameter	Type
model	ParakeetModel
level	string | undefined

Returns

string

---

toolGroupDefaultOpen()fnfunction

Signature

function toolGroupDefaultOpen(group): boolean;

Active and failed groups show every call; clean history retains a visible tail.

Parameters

Parameter	Type
group	ParakeetToolGroupItem

Returns

boolean

---

visibleToolCalls()fnfunction

Signature

function visibleToolCalls(
  group,
  open,
): readonly Readonly<{
  id: string;
  kind: ParakeetToolKind;
  name: string;
  verb: string;
  activeVerb: string;
  label: string;
  paths: readonly string[];
  status: "error" | "unknown" | "running" | "completed";
  durationMs?: number;
  exitCode?: number;
  error?: string;
  sections: readonly ParakeetToolCallSection[];
}>[];

Even a folded group shows recent calls, rather than hiding all tool work.

Parameters

Parameter	Type
group	ParakeetToolGroupItem
open	boolean

Returns

readonly Readonly<{ id: string; kind: ParakeetToolKind; name: string; verb: string; activeVerb: string; label: string; paths: readonly string[]; status: "error" | "unknown" | "running" | "completed"; durationMs?: number; exitCode?: number; error?: string; sections: readonly ParakeetToolCallSection[]; }>[]

---

toolCallDefaultOpen()fnfunction

Signature

function toolCallDefaultOpen(call): boolean;

A failed call opens by default so its error is visible.

Parameters

Parameter	Type
call	ParakeetToolCallView

Returns

boolean

---

disclosureOpen()fnfunction

Signature

function disclosureOpen(state, id, defaultOpen): boolean;

Whether a group or call is currently open.

Parameters

Parameter	Type
state	ToolDisclosureState
id	string
defaultOpen	boolean

Returns

boolean

---

toggleDisclosure()fnfunction

Signature

function toggleDisclosure(state, id, defaultOpen): ToolDisclosureState;

Flip one group or call, recording the reader’s explicit choice.

Parameters

Parameter	Type
state	ToolDisclosureState
id	string
defaultOpen	boolean

Returns

ToolDisclosureState

---

toggleAllDisclosure()fnfunction

Signature

function toggleAllDisclosure(state): ToolDisclosureState;

Expand everything, or collapse everything when the reader has expanded anything. Either way individual choices are cleared.

Parameters

Parameter	Type
state	ToolDisclosureState

Returns

ToolDisclosureState

---

formatToolDuration()fnfunction

Signature

function formatToolDuration(milliseconds): string;

Compact duration: 340ms, 1.2s, 2m 5s.

Parameters

Parameter	Type
milliseconds	number

Returns

string

---

useMarkdown()fnfunction

Signature

function useMarkdown(content): MarkdownDocument;

Parse chat Markdown for headless hosts, including terminal presentation.

Parameters

Parameter	Type
content	string

Returns

MarkdownDocument

---

ParakeetView()fnfunction

Signature

function ParakeetView(__namedParameters): ReactElement;

Render the retained conversation surface within one Parakeet provider.

Parameters

Parameter	Type
__namedParameters	ParakeetViewProps

Returns

ReactElement

---

Parakeet()fnfunction

Signature

function Parakeet(__namedParameters): ReactElement;

Standalone typed composer and exact-message timeline.

Parameters

Parameter	Type
__namedParameters	ParakeetProps

Returns

ReactElement