True while a channel surface is in FOCUS mode: the main call column collapses
(.board-focus on the overlay) and a compact floating call pill (orb + state +
mute / show-thread / end) rides over the surface.
Emitted whenever the EFFECTIVE chrome flips between 'orb' and 'console'.
Whether the typed-input dock is open — a TWO-WAY user door (the strip's Type control / the T hotkey open it; the dock's hide control closes it), volatile and reset per session. Typing never becomes permanent chrome.
ReadonlyConnectionLive turn-state from the session service — drives the banner + connecting screen.
Emitted when the connection lifecycle state changes (e.g. connecting → listening).
A generic hook fired when ANY control is invoked — even one the host hid via inputs and re-rendered itself. Lets a host observe/react to the full control surface from a single binding.
The signed-in user, threaded to the surface panel's artifact viewer.
Emitted when the interface density changes.
The strip's Details peek: shows the surface panel ON DEMAND while it isn't earned yet (disclosure level < 2) — Activity and channel surfaces exist before their content does. Cleared automatically once content earns the panel for real.
Whether developer affordances (open-record links) are revealed. Per-session view state on this shell — off by default, reset with the overlay, never persisted.
ReadonlyDisclosurePROGRESSIVE DISCLOSURE: the levels/milestones model behind the pure-audio-first UX (see RealtimeDisclosureModel). Loaded from UserInfoEngine at construction; content events (onSessionStateChanged, onChannelActivity) raise the volatile session level; milestones ratchet + persist when the call ends. REVIEW mode bypasses disclosure entirely — a past session always renders the full console.
Emitted after the call ends so the host can react (visibility is driven by Active$).
The active environment id, threaded to the surface panel's artifact viewer.
Mic-muted state reflected on the focus pill's mute button.
True while the call is MINIMIZED: the overlay hides itself (CSS, not destruction) so
the host can show its floating "on call" pill WITHOUT losing this shell's merged
session state (delegation cards ride non-replaying streams) or view state (dev mode,
expanded chips, scroll position). The host binds this from Minimized$.
True while the resize handle is mid-drag (brand-tints the handle).
Emitted when the user minimizes the call view (the call stays live).
ReadonlyModelServer-reported realtime model name for the active session — shown subtly in the banner.
Emitted when the mic mute is toggled; payload is the new muted state.
Local mic-muted state, the single source the resolver-independent controls reflect.
Emitted when a gear-gated developer link asks to open an entity record. The host is
expected to bubble this through its standard record-open path (the chat area re-emits
it on openEntityRecord, which Explorer routes via NavigationService). The overlay
minimizes itself first so the live call survives the navigation.
Whether the surface panel is collapsed to its slim strip (reported by the panel).
Wide tier active (a content tab is focused) — drives the DEFAULT width only.
Current expanded panel width in px (rendered as the panel's inline width).
If specified, this provider will be used for communication and for all metadata purposes. By default, if not provided, the Metadata and RunView classes are used for this and the default GraphQLDataProvider is used which is connected to the same back-end MJAPI instance as the Metadata and RunView classes. If you want to have this component connect to a different MJAPI back-end, create an instance of a ProviderBase sub-class like GraphQLDataProvider/etc, and configure it as appropriate to connect to the MJAPI back-end you want to use, and then pass it in here.
Review mode's Close: the host clears its review state, returning to the conversation.
The reviewed session's transcript cues (built from its turns) for the recording player's transcript panel. Empty outside review.
The reviewed session's rehydrated whiteboard, when it saved a parseable Whiteboard channel state — rendered read-only by the review whiteboard tab. Null = no tab.
Whether the conversation renders as TEXT (the thread) or stays voice-first (the
orb hero). A PERSISTED per-user preference (mj.realtimeVoice.captions.v1) —
default OFF: voice-first, the orb owns the screen until the user opts into text.
Review mode's "Start live session": the host clears its review state and resumes the
reviewed session as a new live call (chaining LastSessionId to restore channel states).
ReadonlyStateShared session state — single source for the thread AND the activity rail.
Emitted (px) when the user finishes resizing the surface panel.
Emitted when the user reveals the transcript (opens text from the orb).
StaticɵdirStaticɵfacDisplay name of the agent the voice session fronts (e.g. "Sage").
Allow drag-to-resize of the surface panel. Default true.
May the user reveal the transcript at all? false makes the widget a pure voice orb
with no path to text (and never graduates to a console in 'auto'). Default true.
Fade non-essential controls when the session is idle (orb chrome only). Default true.
Whether the active-channels strip renders. Preserves the historical disclosure gate
(level 2+, RealtimeDisclosureModel.ShowComposer) AND honours the host's
[ShowChannels] input + the resolver's focus rule: a host that sets [ShowChannels]
false hard-disables the strip, and channel-focus mode hides it. The strip component
itself self-hides when no channels are active, so this stays decluttered.
The chrome the widget renders: the ambient 'orb', the structured 'console', or
'auto' (default) which starts as an orb and graduates to a console once the
container is wide enough AND the user has revealed text. Mirrors
RealtimeUiInputs.chrome.
Force dense spacing/typography regardless of width (useful for tight mobile sheets).
Default false — compactness is otherwise inferred from the container width.
In 'auto' chrome, the container width (px) at/above which the widget may graduate
to a console (still gated on text being revealed). Default 560. Mirrors
RealtimeUiInputs.consoleBreakpointPx.
True while the overlay renders a PAST session (review data set, no live call).
The panel's rendered width: slim strip when collapsed, otherwise the current width.
Resizing is meaningless while collapsed or when the surface fills (focus mode), and a
host may hard-disable it via [AllowResize]="false" — in review the resolver's
allowResize is false (no live surface to resize), so this also reads the host flag
directly (defaulting to the historical true) rather than the resolved value, keeping
drag available in review exactly as before.
Returns either the default Metadata provider or the one specified in the Provider property, if it was specified
The reviewed chain's history artifacts for the surface panel's Activity tab.
SESSION REVIEW data: when set (and no live session is active) the overlay renders the reviewed past session instead of a live call. Setting it populates the shared State with the historical thread and prepares the read-only whiteboard tab; clearing it returns the state to its live-merge baseline.
The MJ: Files id of the reviewed session's recording, or null when nothing was recorded.
Bound into the storage media player, which resolves the authenticated audio itself.
The reviewed session record's id — feeds the banner's dev "Open session" link.
Review banner convenience accessors (null-safe against the review data).
Returns either the default RunQuery provider or the one specified in the Provider property, if it was specified
Returns either the default RunReport provider or the one specified in the Provider property, if it was specified
Returns either the default RunView provider or the one specified in the Provider property, if it was specified
ID of the live server-side agent session record, for the banner's dev link.
Show the Activity rail/tab (delegations, artifacts timeline). Default true.
Whether the surface panel's Activity tab should be shown. Reads the resolved
Ui.showActivityTab (host's [ShowActivityRail] AND activity/review AND console)
OR review mode — a past session's activity is always relevant even before the resolver's
console gate would otherwise allow it.
Show the captions toggle. Default true.
Show the channel strip (active interactive channels). Default true.
Show the density picker inside the gear menu. Default true.
The Details (tabs) toggle is offered while live — it's the panel's one door.
Show developer affordances ("open session / open run" links). Default true, but
still additionally gated by the per-session dev-mode toggle — a hard ceiling, not a
force-on.
Show the end-call control. Default true (hosts that own their own end button may hide it).
True while the PURE-AUDIO hero (the orb) owns the main column. Now reads from the
resolved view-model (Ui): the resolver decides hero-vs-thread from the
effective chrome + text intent + review, so host inputs ([Chrome],
[AllowTextReveal], the breakpoint) gate it. Review still always shows the thread.
Show the minimize control (collapse the call without ending it). Default true.
Whether the surface-panel area renders. Driven by the resolved Ui.showSurfacePanel
(console + earned + host's [ShowSurfacePanel]) OR review mode, which always carries the
panel. The Details toggle still earns the panel on demand (it flips surfacePanelEarned).
Show the right-hand surface panel (whiteboard / browser / interactive channels).
Default true; only renders in console chrome and once a panel is actually earned.
A programmatic override bag, merged UNDER the individual inputs — any field also set
via a dedicated @Input() wins over its entry here. Lets a host configure the whole
surface in one binding (e.g. a saved per-context preset) without enumerating a dozen
attributes.
Collapse the surface panel (hide the Details peek). No-op in review (always shown).
End the session (tear down the call) — the imperative twin of the End control.
Short status line for the focus pill (first person — the co-agent owns the work).
Maps the realtime state onto the hero orb's data-state (active turn-states only).
Short first-person status line for the pure-audio hero.
Minimize the call (it stays live) — the imperative twin of the app-bar Minimize.
A callback method that is invoked immediately after Angular has completed initialization of a component's view. It is invoked only once when the view is instantiated.
A callback method that performs custom clean-up, invoked immediately before a directive, pipe, or service instance is destroyed.
A working delegation card's ✕ asked to cancel that delegated run — EXPLICIT user intent (barge-in never cancels work, by deliberate policy). The service calls the server cancel channel and flips the card to a failed "Cancelled by user" result.
The captions toggle = the persisted text-vs-orb switch: on → the thread renders (raising the text disclosure milestone); off → the orb hero owns the screen again, at any level. Persisted per-user so the choice survives refresh and devices.
The composer dock toggled the mic. Syncs the overlay's single Muted source (and the focus pill) and surfaces the MuteChanged / ControlInvoked outputs.
The composer dock opened (strip Type control / type-to-compose keystroke) or closed (the dock's hide control). Opening raises the 'engaged' milestone for the cross-session ratchet — but the dock itself stays a per-session, user-owned toggle either way.
The gear popover picked an interface density — apply + persist + emit. Simple IS the
"pure audio" surface (the standalone headphones control was folded into the gear here): it
returns to the orb-only view AND makes it stick across refresh/next call, so picking it also
closes any open Details peek so the surface is genuinely orb-only — matching the old app-bar
"Pure audio" button exactly. In-session reveals ("Show the conversation", T-to-type, Details)
stay available and ephemeral; switching density back to Standard/Pro/Auto restores the console.
The strip's Details control: peek at (or hide) the surface panel on demand.
Reflect the gear toggle from the controls into the dev affordances.
TYPE-TO-COMPOSE: during a live call, pressing any single printable character (with nothing
focused) reveals the composer, raises disclosure to the engaged level, AND seeds that very
character into the draft — the user just starts typing and their first key is captured (the
old dedicated "T" key is gone; "t"/"T" now types like any other letter, and the visible
"press T to type" hint was removed in favour of this natural behaviour). Ignored while
review/minimized/inactive, with Ctrl/Cmd/Alt modifiers (don't hijack shortcuts), for
non-printable named keys (Enter/Tab/Arrow/Escape/F-keys → key.length > 1), for a bare
Space (ambiguous — no message starts with a space), or when an editable element / a
keyboard-capturing surface (the remote-browser canvas) already holds focus.
App-bar / strip End: tear the session down, then notify the host.
Focus pill: end the call (mirrors the controls row's End button).
Focus pill: leave focus mode (show the thread column again).
Focus pill: toggle the mic mute (routes through the overlay's single mute path).
App-bar Minimize: hide the call view (CSS) — the call stays fully live.
A done delegation card / rail entry asked to view a produced artifact's tab — an EXPLICIT user request, so it may open the (otherwise Details-controlled) panel.
A dev link asked to open a delegated agent run record.
The banner's dev link asked to open the live agent session record.
Double-click the handle: back to the default tier width; persist the reset.
Mousedown on the resize handle: capture the start state and track the pointer document-wide.
Wide-tier flips only move the DEFAULT width — an explicit user width always wins.
Review controls: close the review (host clears its review state).
Review controls: resume the reviewed session as a NEW live call (host handles the start). Flags the upcoming ReviewData→null transition as a CONTINUATION so the historical thread is kept (divider appended) instead of cleared.
The hero's "Show the conversation" affordance — turns the text preference on.
Open the surface panel (the on-demand Details peek), optionally focusing a specific channel's tab. Equivalent to the strip's Details control plus a channel reveal.
OptionalchannelId: stringwhen supplied, the channel tab to reveal once the panel is shown.
Registers (or updates) an INTERACTIVE-CHANNEL tab on the surface panel. The overlay
calls it for every registry-resolved plugin; hosts may also call it for bespoke
template-based panes. Until a registration supplies a plugin / template, the tab
renders the "coming online…" placeholder (re-register the same Key to upgrade).
Safe to call before the panel has rendered — registrations are queued and flushed.
Reveal the transcript programmatically — the imperative twin of the orb's "Show the conversation" affordance. Raises the text disclosure level, turns captions on, and emits TextRevealed.
Set captions (the text-vs-orb preference) to an explicit state. Persisted per-user; turning them on also raises the text disclosure level.
whether captions/text should be shown.
Set the UX interface density (the gear's escape hatch). Applied + persisted immediately; emits DensityChanged.
the density to apply.
Set the mic mute to an explicit state (no-op when already there). Drives the session service, syncs every mute affordance, and emits MuteChanged.
the desired muted state.
Toggle captions (the text-vs-orb preference).
Toggle the mic mute. Drives the session service, syncs the overlay's Muted source + the composer/focus-pill affordances, and emits MuteChanged + ControlInvoked.
The "call mode" overlay for a live real-time voice session. Hosted by the conversation chat area (
<mj-conversation-chat-area>) behindActive$, it fills the conversation panel IN PLACE (position:absolute; inset:0over the panel — not a fixed app-wide dialog), replacing the conversation view including the composer.Two-column layout:
MJ: AI Agent Channelsregistry. Collapsible to a slim strip at the panel level.INTERACTIVE CHANNELS ARE PLUGINS — this shell is channel-agnostic. It subscribes RealtimeSessionService.ActiveChannels$ and registers one surface tab per BaseRealtimeChannelClient (key/title/icon from the plugin); the tab pane creates the plugin's surface component dynamically and the PLUGIN wires its own inputs/outputs. The only channel-generic affordance the shell owns is the FOCUS layout: any channel may request it (via its context's
SetFocusMode→ RealtimeSessionService.ChannelFocus$), which collapses the main call column (.board-focus) and shows the floating call pill.Owns the shared RealtimeSessionState — the SINGLE merge of the service's caption/delegation/narration streams — and passes it to both thread and rail via inputs, so neither duplicates subscription logic.
DEVELOPER MODE: the controls row's gear toggles DevMode (per-session, off by default, never persisted), revealing "Open run" links on delegation cards / rail items and an "Open session" link in the banner. Clicking one emits NavigateRequest and MINIMIZES the call (via RealtimeSessionService.SetMinimized) — the session stays live while the host navigates to the record.
SESSION REVIEW MODE: when the host supplies ReviewData (a loaded
RealtimeSessionReview) and NO live session is active, the overlay renders what went down in that PAST session instead of a live call: the banner shows a "Session review" badge + lifecycle range + close-reason chip; the SAME thread/rail components render the historical caption turns and delegated-run cards (via RealtimeSessionState.LoadHistoricalItems); a read-only Whiteboard tab is registered ONLY when the session saved a parseable Whiteboard channel state. Everything live is DEAD in review — no mic, no captions stream, no composer, no channel strip; the controls collapse to a single "Start live session" button (StartLiveRequested, which resumes by chaininglastSessionId) and a Close button (ReviewClosed).