Review mode: whether the "Start live session" action is offered. A host turns it off where a voice session cannot start (the chat area does so while a draft fork is open).
The host's own words for why the call shows no avatar, per reason (for example its product's name for "this app").
A reason it leaves out keeps the stock line from ng-realtime-media (AVATAR_NOTICE_TEXT). unknown words a reason
this version doesn't know, such as a newer server's, in place of AVATAR_NOTICE_CALL_UNKNOWN_REASON_TEXT.
The microphones and cameras the composer's device menu offers: the call's microphones, and its cameras while the camera is open (a browser names cameras only once the user has allowed one).
Which captures the call offers (see RealtimeSessionService.CaptureOffers$); the composer shows Camera and Share from it.
The user's camera and screen share (see RealtimeSessionService.Captures$).
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, as the panel reports it. A panel created again starts this
way (the overlay binds the panel's Collapsed). Back to false while the panel's area is hidden for any reason but
room, so the panel comes back expanded after Details, a channel on the stage or a review turning into a live call,
and as the user left it when only the call's width hid it.
Wide tier active (a content tab is focused) — drives the DEFAULT width only. The panel reports it when it flips; a panel created again also sets it from the tab it lands on.
Current expanded panel width in px (rendered as the panel's inline width).
Where the user put each picture-in-picture box, by channel key, as fractions of the stage.
The agent's place in the call, as last reported to the stage, or null while the call shows none.
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.
The panels of the page the Share menu offers under "This panel": those on screen, in page order, leaving out any that holds this call. Empty where the browser cannot share a single panel.
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.
ReadonlySurfaceWhich channel surfaces the stage holds and where each shows.
Emitted when the user reveals the transcript (opens text from the orb).
The video sources the agent can or could see right now (see RealtimeSessionService.VideoSources$).
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.
The newest caption, as the captions over the agent's video show it: the user's is marked "You". null before any.
Why this live call shows no avatar its agent asked for, while the notice shows: from the moment the call connects
until the user dismisses it or it hides itself. null otherwise, and always in review.
The notice's line, in the host's words when it gave some (AvatarNoticeLabels); a notice without a reason (one this version doesn't know) reads the call's line for it.
Why the call ended, when its client said so (a relayed call that reached its time limit): the label the banner and the
hero show in the 'error' state in place of "Connection error"; null otherwise.
The camera while the user checks it, before the agent sees it; null otherwise. The camera check card shows it.
Whether the camera is on or starting: the composer's Camera button reads as on.
True while a channel's surface is on the stage (FOCUS mode): the main call column collapses
(.board-focus on the overlay) and a compact floating call pill (orb + state +
mute / show-thread / move / end) rides over the surface. A surface that presents the agent
(PresenterOnStage) takes the agent's place in the call instead, so it is not focus mode.
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).
What the call says while no microphone works: the call lost its microphone (the one in use failed and so did the
default, or the last one went away), so the agent hears nothing until the user picks one in the device menu. Shown
under the banner for as long as that lasts. null while the microphone works, outside a call, and always in review.
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.
Whether the surface on the stage presents the agent: its channel shows the agent's video (the Avatar). It lies over PresenterSlot, in the agent's place in the call (the hero, or above the thread in the console), rather than filling the overlay.
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 RunView provider or the one specified in the Provider property, if it was specified
The camera the device menu shows: the one being switched to, else the one in use.
The microphone the device menu shows: the one being switched to, else the one in use.
ID of the live server-side agent session record, for the banner's dev link.
Whether a share is on or starting: the composer's Share button reads as sharing.
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.
Whether captions run over the agent's video: they are on, and the video presents in the hero.
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.
The channel whose surface is on the stage (the pill's exit routes back to it), or null.
The slot the stage lays the active channel tab's surface over: none while the panel is away.
The element the stage lays its stage surface over: the agent's place while it presents, else none (it fills the stage).
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 the default change detector has completed one change-check cycle for a component's view.
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.
The user moved to another channel's tab (or to a tab that is not a channel). When the model can watch only one video source, the channel the user is looking at is the one it sees.
The user dismissed the notice: it does not come back in this call.
The camera check's "Turn on camera": the agent sees the camera from now on.
The camera check's "Not now": the camera turns off.
The composer's Camera button. The session starts or stops the camera; its channel's box shows it, or why it could not start.
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 panel's active channel slot moved, or went away.
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.
A microphone or camera picked in the composer's device menu: the session switches to it. The menu shows the pick while the switch runs, then the device in use: the new one, or the old one when the new one could not open. A pick of the device in use changes nothing. While no microphone works, the session opens the picked microphone, and the menu then shows it, or none when it could not open.
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: the surface on the stage goes back where its channel places it (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.
The user moved a channel's surface ("Move to…", "Bring it here").
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.
The user moved or resized a picture-in-picture box: keep it and save it.
The user put every surface back where its channel places it (and every picture-in-picture box back in its corner).
Review controls: close the review (host clears its review state).
The composer's Share button or menu: the session asks the browser's picker, offering the kind of surface picked first, or this tab, to share the picked panel alone.
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 composer's Stop sharing.
The hero's "Show the conversation" affordance — turns the text preference on, and opens the thread even over the agent's video.
The user picked the video source the agent sees in the "agent can see" chip, or let the call choose again (null).
The session's arbiter applies it and tells the agent.
The user switched one of the agent's video sources on or off in the "agent can see" chip. The session applies it (and remembers it per channel) and tells the agent.
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.
Whether the call body shows the connecting screen for state: while the call connects, outside review, unless the
agent's video presents in the hero. The hero then stays, so a resume on a new connection keeps the video in its place
with its last frame on screen, and the video's tile says the call is connecting. Taking the hero away would take the
video's place with it, and the stage would lay the video over the whole call until the hero came back.
ReadonlySwitchMoves the camera being checked to another device: the camera check's picker.
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). Every plugin's surface lives on ONE STAGE (
mj-media-stage) over the whole overlay: created the first time it is seen, laid over its tab's pane while that tab is active, and kept until its channel leaves (see RealtimeSurfaceStageModel). The PLUGIN wires its own inputs/outputs. Each surface starts where its channel's registry row places it (its tab unless the row says otherwise). The user moves it with "Move to…" (beside its tab, in the call pill, or on a picture-in-picture box): to the STAGE, a picture-in-picture box, its tab, or out of sight, as far as its channel allows. The moves are saved per user and carry over to later sessions. A surface on the stage is the FOCUS layout: the main call column collapses (.board-focus), the surface fills the overlay and the floating call pill appears. A channel may ask for it too (via its context'sSetFocusMode→ RealtimeSessionService.ChannelFocus$), which moves its surface to the stage or back.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).