zidane-ui/chat/composer

Renders the agent profile pill of the composer controls and its menu, with the current profile checked.

The agent dialog (see the header).

The session's next approval, docked above the prompt (see the header).

The archived session's banner in place of its composer.

The files the composer just refused, one line each, until dismissed. Nothing renders without any.

A row of staged attachment tiles that collapses when its last tile leaves.

Renders the composer's attachments as a row of tiles: image thumbnails and file tiles, each with a remove button.

Renders the chat prompt box: a text editor with staged attachments, a controls row, and Send or Stop. Enter sends, Shift+Enter adds a line, Escape stops a running agent, and the arrow keys recall earlier prompts.

Renders the composer's badge strip (see the module comment). Place it as the first child of the composer's tray ring, before the card.

The left cluster: agent, model and options pickers (see the header).

The column above the prompt. zg-composer-dock carries :empty { display: none } (styles/composer.css): every child renders null on an idle session, and a zero-height flex item would still consume one of the footer column's 8px gaps, pushing the composer down at rest.

Provides a ComposerHost to the composer components below it.

The right cluster: the run chip and the context orb. The only part of the conversation that re-renders on the run's progress ticks.

Renders the context window breakdown: a stacked bar and a list of categories with their token shares. While there is no breakdown it shows a plain gauge from the fallback values.

Renders the context usage donut and, in its popover, the window breakdown and session cost.

The badge strip of one conversation (see the header).

One raised card in the dock.

One line of a dock card: glyph, body, actions.

The model options dialog (see the header).

Renders a Composer bound to the ChatHost in context for one session. Controls the host leaves out are hidden; without send nothing renders.

The context orb over the host (see the header).

The host's model list (see the header).

The model options pill for a live session: ModelOptionsPicker (reasoning effort, then feature toggles) applying picks to the session, each remembered for its model so the next new chat starts there.

The model chain pill. Run-sticky fallback: when this run's stream failed on the picked model and the agent advanced down its chain, the pill shows the model actually serving the run (serving), until the next run or a re-pick.

A composer pill naming the host a new chat runs on, opening a menu of the hosts (unreachable ones disabled).

Renders the image models in the chat models' list. A pick reports its key.

The model pickers' footer: the keys, the hidden legacy models, how many are selected.

The pickers' header, the same for every list (chat models, image models): the search field across the full width, a row with the caller's toolbar (the popover's Chat / Image tabs) and the Legacy switch at its end, then the provider pills. One padding around it and one gap between rows, and each row keeps its height when it is empty, so switching lists or filtering to nothing never moves the list below.

Renders a searchable list of models for building a fallback chain: the first entry is the primary, the rest are fallbacks. A plain pick on a chain of one swaps the primary.

Renders the model pill with a popover over the chain picker. A plain pick commits and closes; a chain edited in the popover commits when it is dismissed.

One row of the model chain picker: the model's name and meta, and its place in the chain.

Renders the picker's sections and the rows of each that are in view.

Renders the chain the model pill stands for, as tooltip content.

A capability glyph with a one-line tooltip. The tooltip is portalled: the rows sit in a scrolling list that would clip it.

A model list's sticky section header: a provider, the pinned chain, or a typed id's routes.

A picker row's meta, in order: legacy, its details, the window (or not in catalog), then the capability glyphs: reasoning, reference images, transparency, and a lock with the reason when the row is unavailable.

Renders the model options pill and its menu: a reasoning effort section and feature checkboxes. Picks apply in place and keep the menu open.

Renders the model pill and popover over the models a host offers. It picks one model with no fallback chain.

The Model dialog (see the header).

Renders the model pill and the popover around a model list.

The provider chip: its color dot and name, with the account when the provider has several ("Anthropic (Work)").

The model chain picker's tabs: a pill for the pinned chain, then one per provider section.

The reasoning glyph, when the model supports reasoning effort.

The model's context window, or not in catalog for a typed id the catalog does not know. Nothing when the window is unknown.

Renders the trigger chip for a composer picker, an item of the controls' segmented track. Spread a Popover trigger's props onto it.

Renders the folder pill and its project menu (see the header).

Holds every session's prompt ring for ↑ / ↓ recall, for the composers below it.

The retry pill (see the header).

The run's live indicator (see the header).

The draft's Chat / folder toggle (see the header).

Renders select-turn mode's keys and its exit in the composer's dock, or nothing while the mode is off here.

Renders the Send or Stop button: a circle that sends the draft, or stops the run while one streams and can be stopped.

Renders the server folder pill and its project menu (see the header).

The popup over the caret: one row per item, the keyboard cursor raised.

Forgets every registered composer scope and focus claim. For tests.

The sentence a composer shows for a file it did not attach.

Every previewable attachment as one gallery: images, PDFs in the browser's viewer, and text as its decoded preview.

Whether pick can join chain as a fallback: no other account of its provider is in it.

A ChatHost's models as catalog rows, in the host's order.

The composer receiving scopeKey (null: a folderless draft) is the window's: pushes without a target go to it until the returned release (a no-op once another claim replaced it).

Returns the display color for a context category id, with a muted fallback for unknown ids.

1M, 1.5M, 200k: the row meta has no room for 1.00M.

Computes the orb's percent and color from a used fraction.

Decodes a data: URL's payload as UTF-8 text. Returns an empty string when the URL has no payload and a placeholder message when decoding fails.

Map an attachment to a Shiki language id. Extension wins; falls back to MIME hints (+json, +xml, text/markdown); unknown → plaintext so the preview still renders, just without colour.

The row an imageModel setting names; when it is empty or stale, the model the tool falls back to (isDefault), else the first available one.

The model a value names: a provider/model key, or a bare id (the first provider offering it).

Move keyboard focus back to the composer (Esc out of a panel card).

Move keyboard focus to the window's composer, or, while none takes it (a conversation switch is still mounting it, or re-keying it to a scope that resolves later), to the next composer to subscribe.

Byte counts for people: 512 B, 1.5 KB, 2.0 MB.

Section a row lists under: its provider, or its provider's account when there are several.

Whether a composer in this window receives scopeKey.

Whether the window has a composer: where a push without a target goes (producers without a scope of their own).

Image models as model-list rows: no context window or reasoning, the capabilities and availability instead.

providerKey/modelId, the form Settings.imageModel stores.

Whether the caret is collapsed on the very last position of the document.

Whether the caret is collapsed on the very first position of the document.

Whether the composer receiving scopeKey (null: a folderless draft) is the window's: the one a push without a target goes to.

A PDF attachment: previewed in the browser's own PDF viewer.

Treat as text any attachment whose MIME is in the text/* family, or one of the structured-text types we routinely encounter (JSON, XML, common script languages that browsers tag as application/*). Falls back to an extension allowlist for files the OS picker presents without a MIME — extensionless dotfiles and a handful of common code extensions land here so the preview is useful.

A row's lineup identity (currentModelKeys: provider + model, whatever the account).

The order to save after the user moved badges: the order shown now, with each saved id that is not shown kept right after the shown badge it followed, so it comes back in its place.

Returns the provider/model key of a model, the form SendInput takes.

The catalog's current models (core currentModelKeys: the newest of each family, by lineupKeyOf), worked out once per catalog: hosts keep theirs between openings, and it means parsing every model id. Read-only.

A model's natural name (Opus 4.6), from the catalog's display name when it lists the model.

Search rank of one entry against the query terms, or null when a term is missing. Lower is better: a term at the start of the model id beats one at a word start inside it, which beats a substring of the id, which beats a hit only in the name / provider corpus.

The profile after currentId in ids, wrapping; the first one when currentId is not listed. null when there is nothing to switch to.

"Use this id via …" rows for a typed model id, one per provider in the catalog (the provider the query names first, then the current one, then the rest), minus routes the catalog already lists. Empty unless the query names an id worth offering: when the catalog matched something, only an id-shaped query (a digit, -, ., / or :, 3+ characters) gets typed routes, so a plain word like "claude" stays a search.

Takes the attachments pushed to a composer.

Takes the drafts pushed to a composer.

Takes the focus requests pushed to a composer.

Takes the text inserts pushed to a composer.

Takes the file mentions pushed to a composer.

Takes the prompts pushed to a composer.

Badges in the order to show them: sorted by order (stable for ties), then the saved order applied over the slots of the badges it names.

ISO-stamped filename for a paste-as-attachment write.

The picker's list as groups. Empty query: the chain first ("In use"), then each provider in catalog order with its current models (or all of them with showLegacy), chain members not repeated. With a query: every model of every provider that matches, grouped by provider, groups ordered by their best match, rows by score then catalog order.

The pick a catalog row makes: its provider, model and (when the provider has several) account.

Plain text → TipTap doc JSON, one paragraph per line. setContent with a string parses it as HTML — multi-line history entries would collapse to a single run and angle brackets would be swallowed as tags. Building the JSON directly keeps recalled prompts (and restored drafts) byte-faithful. Empty text yields a single empty paragraph, the minimal valid block+ doc.

"Anthropic", or "Anthropic (Work)" for one of several accounts. Plain text: it also names the account in tooltips and settings rows.

Stage an attachment in a composer.

REPLACE the composer's draft (Edit message): the editor holds text, the staged attachments become attachments, and the caret lands at the end.

Append plain text at the end of the draft and focus the composer (a /command awaiting arguments).

Insert an @<path> file mention at the caret. path is relative to the session cwd, the same form the composer's own @ completion produces.

Send text through the composer's send path, leaving the draft alone (palette prompts, Continue / Retry).

Reads a file into a ComposerAttachment with a data: URL, as the shared rule says (planAttachment): images, PDFs and text attach; an image in another format, or over the image cap, is re-encoded to fit, and keeps the file as picked in original (up to the file cap) so the host can save it for the agent and say it was converted. An animated GIF under the cap goes as it is, every frame. Rejects with an AttachmentRefusedError for a file the rule refuses (or an image that cannot be decoded), and with the read error when the file cannot be read.

Identity of a pick: provider, model and account (core modelPickKey, the one key chains compare by).

The mounted composer receives scopeKey (null: it has no scope, a folderless draft); call the returned function when it stops.

A chain as the catalog lists it, resolvePick on each entry: what the picker shows (In use, places, checks) and edits. The chain itself when no entry changes.

A pick as the catalog lists it. A pick naming no account runs on its provider's active account: where the catalog lists that provider per account, the pick is that account's row (the one marked active, else the first account that has the model). Any other pick comes back as it is.

The text of a resource's error, null for none.

A catalog row's pick identity.

Should a plain-text paste become a .txt attachment chip instead of inline editor text? Mirrors the TUI's rule (line count after CRLF normalisation + trim) with a lower character ceiling on top.

One trigger as a Tiptap extension. source and state are refs so the editor, built once, always reads the latest props and popup.

Whether a focusComposerWhenReady request waits for a composer; taking it clears it.

Build a text attachment (UTF-8 data URL) the composer can carry.

An edit made on a resolved chain (resolveChain), back on the chain it was resolved from: an entry that was there keeps its own form (a pick naming no account still names none, so it still follows the active account), a new one stays as it was picked.

The profiles cwd offers ('': no folder). Empty until read, and without agents.

Manages the composer's staged attachments and the ways in: paste, drop, and the file picker. Images, PDFs and text files attach; anything else is refused with a notice.

The notices about files a composer did not attach: refuse words what readAttachment rejected with; they clear on dismiss, or ATTACHMENT_NOTICE_MS after the latest one.

Removal with the tile's exit: removeAttachment marks it exiting, and the tile's width transition (or a timer on the exit motion's length, when motion is reduced or off and there is no transition) drops it from the list. Only a removal still in flight is finalized: once the list is replaced (clearExiting), a late timer would remove a tile of the NEW list sharing that id.

Cache hints for a picker's options, fetched once per open: an option's estimate is asked the first time it renders. The first answer decides for all: no live agent, an expired cache, a short prompt or an older daemon means no option can show one, so nothing more is asked. Never blocks a pick; a failed estimate shows nothing.

Where a scoped producer pushes: its scope's composer while one is mounted (live), else null.

The nearest ComposerHost; an empty host (every capability left out) outside a provider.

The composer's strings: defaults, then <LabelsProvider> overrides, then the provider's labels.

Names a model as the model picker does; re-renders when the catalog arrives or changes.

A provider's label as the model picker groups it (Anthropic).

Quick-cycle through the folder's agent profiles (the cycleAgent shortcut). Mirrors the TUI's Shift+Tab: the next profile in the picker's order, wrapping; a no-op with one profile, while the session runs, or while it waits on an approval (ApprovalsHost) or a question (ChatHost).

A new chat's starting effort and options on modelId, live (its draft's pick, the configured defaults, the last used).

The new-chat draft's target, reset with the draft.

Live hasFocusedComposer.

A host resource, kept current while mounted (IDLE_RESOURCE for null).

A running session this window did not see start (opened, reloaded or reconnected mid-run): reads its run from the host once (runs.progress), so the chip neither restarts its time nor counts its output from zero. A run whose run:start it saw counts from the start already.

The catalog to list: outer when the caller loaded one, else the host's for cwd on hostId.

The remembered knobs of the nearest host, for actions.

The model picker's preferences, live.

The host's picker preferences store (an in-memory one when it has none).

The new session's defaults in a space, over the provided ComposerHost.

The prompt ring from the nearest PromptHistoryProvider. Throws outside one.

Keeps store on the chat host's provider check.

The last effort and options used with modelId, live.

Cost of turns settled since the last settling cost read.

Whole-second elapsed counter for the session's current run, from its start (the host's, so neither switching conversations nor opening a window restarts it). Ticks every tickMs: 250 ms by default so 0s → 1s is not laggy, but renders once per second.

One field of a session's run counters (store: RunMeter.session(id), null for none).

Output tokens of the run's settled parent turns.

The streaming parent turn's live counters, null between turns.

When the run started (epoch ms), null while this window knows of none.

Binds the send flow to the hosts and the app's inputs.

The context gauge of a session alone (what the model and effort pickers read): the same keyed read as useSessionMeters', so one request.

The meters of the session shown.

The running work to show for a conversation (see the header).

The chain after making pick the primary: one account per provider, so entries naming another account of its provider drop (core filterChainFallbacks would drop them anyway, silently).

How long until items should show, in ms: 0 when they already should.

A file readAttachment did not attach, and why.

How long the notices about refused files stay, in milliseconds.

The default slot of a badge without an order.

A generic file icon (the PDF icon for a .pdf) and the name. The default AttachmentRowProps.attachmentLabel.

Every reasoning effort level the agent knows, in the TUI picker's order.

Cap on a PDF's or a text file's bytes.

Cap on an image's bytes. Base64 inflates ~33%, so this keeps the encoded payload under Anthropic's 5 MB image ceiling while covering essentially every screenshot. A composer scales a bigger image down to fit.

Why a chat action is disabled (its tooltip).

Options drawn as a glyph wherever they are shown (the pill, the menu row).

Character ceiling for SINGLE-line (or few-line) pastes. In the GUI a 50 KB one-liner soft-wraps into a screenful of editor, so a paste of this many characters folds too. The TUI's own ceiling is higher (PASTE_INLINE_MAX_CHARS in src/tui/prompt/paste.ts, 10,000).

Line threshold above which a multiline paste folds into a .txt attachment. It matches the TUI (planTextPaste in src/tui/prompt/paste.ts uses lines.length > 10 after trimming leading and trailing blank lines). Short multiline pastes (stack traces, paragraphs) stay inline so the user can edit them; anything longer arrives at the model as a discrete document part instead of a wall of prompt text.

The reasoning levels a ChatHost accepts in SendInput, from least to most.

The character that opens each completion: @ for mentions and / for commands.

Work that ended keeps showing this long.

Work shorter than this never shows.

Props for AgentPickerDialog.

Props for AgentPicker.

An agent profile the picker offers.

Props for ApprovalDock.

Props for ArchivedBanner.

Props for AttachmentNotices.

Props for AttachmentRow.

Props for AttachmentTiles.

One badge of a ComposerBadges strip.

Props for ComposerBadges.

Props for ComposerControls.

What the next new chat starts on, as the app decides it.

Props for ComposerDock.

A whole draft: its text and the attachments to stage, ready (data URLs).

Imperative handle of the Composer, reached through its ref.

Props for ComposerHostProvider.

Props for Composer.

Props for ComposerStatusPills.

What the composer hands to onSend.

The one composer meant to take a push (a session key, a draft's scope); without one, the window's composer.

The shaped, render-ready breakdown.

Props for ContextBreakdown.

The session's spend, as the popover's last row and the orb's tooltip show it.

The orb's share in percent and its color, for a breakdown's fallback gauge.

Props for ContextOrb.

Everything the orb and its popover show.

Props for ConversationBadges.

The highlighted row, and what moved it there: only the keyboard scrolls the list to follow it.

Options for useCycleAgent.

Props for DockCard.

Props for DockRow.

A saved server a draft can run on.

The draft's target and its picks, as the composer's where menu and folder pickers read them.

What useDraftTarget reads from the app.

A draft target picked outside the composer.

Props for EffortPickerDialog.

Props for HostAgentPicker.

Props for HostComposer: the ComposerProps the host does not drive, plus sessionId, defaultModel, defaultThinking, and footer.

Props for HostContextOrb.

Props for HostModelChainList.

The image models tab of a model picker.

Props for HostModelOptionsPicker.

Props for HostModelPicker.

Props for HostPicker.

Props for ImageModelList.

One completion offered by a SuggestionSource: a file, a session, a command.

A model catalog as a picker reads it.

Props for ModelChainFooter.

Props for ModelChainHeader.

The Image tab of ModelChainPopover.

Props for ModelChainList.

Props for ModelChainPopover.

Props for ModelChainRow.

Props for ModelChainRows.

Props for ModelChainTooltip.

A model picked from a provider's catalog.

Props for ModelFlag.

Props for ModelGroupHeader.

Props for ModelMeta.

A feature toggle a model declares.

Props for ModelOptionsPicker. L is the type of the effort levels.

Props for ModelPickerDialog.

Props for ModelPickerFrame.

Props for ModelPicker.

Props for ModelProviderChip.

Props for ModelProviderPills.

Props for ModelReasoning.

Props for ModelWindow.

What a new session starts with, and the writers of each pick.

What ordering needs of a badge: its id and its default slot.

One section of the model picker list.

Props for PickerPill: the attributes of a button, plus its content and collapsible.

Props for ProjectMenu.

Props for PromptHistoryProvider.

The per-session prompt ring usePromptHistory returns.

Props for RetryPill.

Props for RunStatusChip.

Props for ScopeToggle.

Props for SelectTurnHint.

Props for SendButton.

The composer's send and stop.

What useSendPrompt sends from and through.

Props for ServerScopeToggle.

A conversation's meters.

What useSessionMeters reads of a session.

Props for SuggestionPopup.

Feeds one completion trigger of the composer: the items for what the user typed, and how a picked item is written into the prompt.

The open popup, as the composer renders it.

The icon and name a file tile shows; fallbackIcon is the icon for a name with nothing to say.

The tint of a badge's icon: the theme's quiet tones and its status colors.

false (or a rejection) keeps the draft: the composer puts it back.

A stream being retried (the stream store's retry state).

One of the reasoning effort levels in EFFORT_LEVELS.

The kinds of model the popover lists: chat models or image models.

Where the default model comes from.

Where Enter sends the draft: send as a new prompt, steer into the run in flight, or queue for after the run ends.

Which trigger a completion belongs to: mention (@) or command (/).

SendInput.thinking's levels, least to most: what a ChatHost takes.