@opengeni/react 3.1.0 → 3.1.2

package/dist/components/remark-soft-line-breaks.d.ts

@@ -0,0 +1,38 @@
+/**
+ * remark: render a single newline inside prose as a line break.
+ *
+ * CommonMark folds a lone line ending inside a paragraph into a space, so an
+ * agent writing `1\n2\n3` shows "1 2 3". Chat surfaces (ChatGPT, GitHub
+ * comments) keep the line, which is what message authors expect. This plugin
+ * turns every line ending inside an mdast `text` node into a `break` node — the
+ * same result as `remark-breaks` — while leaving code (`code` / `inlineCode`
+ * carry `value`, not `text` children), raw HTML, and block structure (lists,
+ * tables, blockquotes, headings, blank-line paragraphs) untouched.
+ *
+ * Unlike `remark-breaks` (built on `mdast-util-find-and-replace`, which drops
+ * positions on the split nodes), every split text node keeps a source position.
+ * Streaming tip ink (`rehypeStreamReveal`) keys fade-in on those offsets, so a
+ * positionless line would render without ink and snap in at the stream tail.
+ *
+ * Structural local types keep the module dependency-free, like
+ * `stream-reveal.ts`; the renderer casts once at the plugin seam.
+ */
+type MdPoint = {
+    line?: number | undefined;
+    column?: number | undefined;
+    offset?: number | undefined;
+};
+type MdPosition = {
+    start?: MdPoint | undefined;
+    end?: MdPoint | undefined;
+};
+type MdNode = {
+    type: string;
+    value?: string | undefined;
+    position?: MdPosition | undefined;
+    children?: MdNode[] | undefined;
+};
+export declare function remarkSoftLineBreaks(): (tree: MdNode, file?: {
+    value?: unknown;
+} | undefined) => void;
+export {};

package/dist/components/sandbox-files.d.ts

@@ -43,6 +43,8 @@ export type SandboxFilesProps = {
     workspaceWaking?: boolean | undefined;
     /** Whether live reads are currently authoritative. */
     liveWorkspaceReady?: boolean | undefined;
+    /** Failed live negotiation; never present a failure as an ongoing wake. */
+    workspaceError?: Error | null | undefined;
     /** Deliberately wake the machine to read content absent from the capture. */
     onWakeWorkspace?: (() => void) | undefined;
     themeType?: "dark" | "light" | undefined;
@@ -55,4 +57,4 @@ export type SandboxFilesProps = {
  * surface deliberately does NOT replicate the changed-files list, and does not
  * diff here — one job per tab). The agent commits; the human reviews.
  */
-export declare function SandboxFiles({ files, git, fileSystemAvailable, usePierre, editable, onEditIntent, initialSelectedPath, onSelectedPathChange, isNodeVisible, requestedPath, requestedLine, requestedPathRequestId, requestedPathReady, workspaceResting, workspaceWaking, liveWorkspaceReady, onWakeWorkspace, themeType, className, }: SandboxFilesProps): import("react").JSX.Element;
+export declare function SandboxFiles({ files, git, fileSystemAvailable, usePierre, editable, onEditIntent, initialSelectedPath, onSelectedPathChange, isNodeVisible, requestedPath, requestedLine, requestedPathRequestId, requestedPathReady, workspaceResting, workspaceWaking, liveWorkspaceReady, workspaceError, onWakeWorkspace, themeType, className, }: SandboxFilesProps): import("react").JSX.Element;

package/dist/components/sandbox-workspace.d.ts

@@ -58,6 +58,13 @@ export type UseSandboxWorkspaceTabsOptions = ClientOverride & {
      * attachment, and navigation callbacks are not activated.
      */
     surfaces?: readonly SandboxWorkspaceSurface[] | undefined;
+    /**
+     * Whether this viewer may read the workspace machine fleet
+     * (`GET /machines`, permission `enrollments:read`). Defaults to true. Pass
+     * false for a viewer without it: the dock then never requests the fleet and
+     * the machine chip derives from the session's own capabilities alone.
+     */
+    machinesEnabled?: boolean | undefined;
     /** Override the source-driven default tab (e.g. a host landing tab id). When
      *  omitted the workbench picks Changes-vs-Files from capture or live Git. */
     initialTab?: string | null | undefined;
@@ -129,6 +136,12 @@ export type SandboxWorkspaceProps = ClientOverride & {
      * Terminal, Browser, and Desktop. Disabled surfaces remain behaviorally dormant.
      */
     surfaces?: readonly SandboxWorkspaceSurface[] | undefined;
+    /**
+     * Whether this viewer may read the workspace machine fleet
+     * (`GET /machines`, permission `enrollments:read`). Defaults to true. Pass
+     * false for a viewer without it so the dock never requests the fleet.
+     */
+    machinesEnabled?: boolean | undefined;
     /** Host tabs injected BEFORE the workbench tabs (e.g. a "Run" landing tab). */
     leadingTabs?: WorkspaceTab[] | undefined;
     /** Host tabs injected AFTER the workbench tabs (e.g. a "Debug" tab). */
@@ -137,6 +150,11 @@ export type SandboxWorkspaceProps = ClientOverride & {
      *  omitted the workbench decides from the durable workspace capture. */
     initialTab?: string | undefined;
     onActiveTabChange?: ((activeTab: string) => void) | undefined;
+    /** Open a built-in or host-injected tab. A new requestId reopens the same tab. */
+    openTabRequest?: {
+        tab: string;
+        requestId: number;
+    } | null | undefined;
     initialFilePath?: string | null | undefined;
     onFilePathChange?: ((path: string | null) => void) | undefined;
     /** Presentation-only filter for Files tree nodes and selected-file viewing. */

package/dist/components/secret-question-field.d.ts

@@ -0,0 +1,31 @@
+import type { HumanInputQuestion, HumanInputSecretSaveTo, HumanInputSecretSpec } from "@opengeni/sdk";
+import { type HumanInputFormMessages, type SecretFieldReading } from "../human-input-model.js";
+/** Read and clear one secret field at submit time; the value never enters React state. */
+export type SecretFieldHandle = {
+    read: () => SecretFieldReading;
+    clear: () => void;
+    focus: () => void;
+};
+export type SecretQuestionFieldProps = {
+    question: HumanInputQuestion & {
+        secret: HumanInputSecretSpec;
+    };
+    fieldId: string;
+    messages: HumanInputFormMessages;
+    autoFocus: boolean;
+    /** Save to targets this person may write. Defaults to all three. */
+    allowedSaveTo?: readonly HumanInputSecretSaveTo[] | undefined;
+    error?: string | undefined;
+    /** Question prompt chrome rendered by the form (multi-question cards). */
+    describedBy?: string | undefined;
+    register: (handle: SecretFieldHandle | null) => void;
+    /** The person changed the field: clears a stale validation error. */
+    onEdited: () => void;
+};
+/**
+ * The ask card's secret field: an uncontrolled password input (read through a
+ * ref, so the value never reaches React state, props, logs or storage) with
+ * show/hide, optional Generate, an optional username placed first so password
+ * managers pair the two, soft `looksLike`/`pattern` hints, and Save to.
+ */
+export declare function SecretQuestionField({ question, fieldId, messages, autoFocus, allowedSaveTo, error, describedBy, register, onEdited, }: SecretQuestionFieldProps): import("react").JSX.Element;

package/dist/components/secret-ref-chip.d.ts

@@ -0,0 +1,35 @@
+import type { HumanInputSecretAnswerResult } from "@opengeni/sdk";
+import { type ReactNode } from "react";
+import { type SecretReferenceLike, type SecretsUi } from "../secrets-ui.js";
+export { secretReferenceLabel, secretReferenceLabelText, type SecretReferenceLabel, } from "../secret-reference-label.js";
+export type SecretRefChipProps = {
+    reference: SecretReferenceLike;
+    /** Link to the item when the host provides `hrefForReference`. Off inside other controls. */
+    linkable?: boolean | undefined;
+    className?: string | undefined;
+};
+/** One secret reference as a chip. Focusable only when it links. */
+export declare function SecretRefChip({ reference, linkable, className }: SecretRefChipProps): import("react").JSX.Element;
+export type SecretRefTextProps = {
+    text: string;
+    linkable?: boolean | undefined;
+    chipClassName?: string | undefined;
+};
+/**
+ * Text with each valid secret reference as a chip. Malformed reference-like
+ * text stays plain, and without a `SecretsUiProvider` the text is unchanged.
+ */
+export declare function SecretRefText({ text, linkable, chipClassName }: SecretRefTextProps): import("react").JSX.Element;
+/** Fast path: only text that mentions a reference is tokenized. */
+export declare function mayContainSecretReference(text: string): boolean;
+export declare function renderSecretRefText(ui: SecretsUi | null, text: string, options?: {
+    linkable?: boolean | undefined;
+    chipClassName?: string | undefined;
+}): ReactNode;
+export type SecretAnswerChipProps = {
+    result: HumanInputSecretAnswerResult;
+    label: string;
+    className?: string | undefined;
+};
+/** The answered ask card: "Saved to Private › GitHub", plus the username. Never a value. */
+export declare function SecretAnswerChip({ result, label, className }: SecretAnswerChipProps): import("react").JSX.Element;

package/dist/components/session-capability-frame.d.ts

@@ -0,0 +1,37 @@
+import { type ReactNode, type RefObject } from "react";
+export type SessionCapabilityFrameProps = {
+    name: string;
+    subtitle: string;
+    logo: string | null;
+    typeLabel: string;
+    description: string;
+    skill: boolean;
+    expanded: boolean;
+    complete: boolean;
+    /** Completion copy must reflect the provider's actual scope of access. */
+    completeLabel?: string;
+    actionLabel: string;
+    /** Direct navigation actions should not announce a dialog on the card. */
+    opensDialog?: boolean;
+    note: string;
+    onOpen(): void;
+    onClose(): void;
+    busy?: boolean;
+    opener?: RefObject<HTMLButtonElement | null>;
+    cardRef?: RefObject<HTMLElement | null>;
+    children?: ReactNode;
+    /** A catalogue row can own the opener while reusing the same details dialog. */
+    dialogOnly?: boolean;
+    /**
+     * Replaces the action when the viewer cannot start setup here (the provider
+     * is not configured, or someone else must connect it). Say why and who can.
+     */
+    actionUnavailable?: ReactNode;
+    /** Host-owned content inside the card, under its status or actions. */
+    details?: ReactNode;
+    /** Protected setup can stay in the conversation instead of opening a dialog. */
+    inlineSetup?: ReactNode;
+};
+/** The same conversation card in the console and embedded clients. Setup
+ * content owns the provider flow; this frame owns identity and protected focus. */
+export declare function SessionCapabilityFrame({ name, subtitle, logo, typeLabel, description, skill, expanded, complete, completeLabel, actionLabel, opensDialog, note, onOpen, onClose, busy, opener, cardRef, children, dialogOnly, actionUnavailable, details, inlineSetup, }: SessionCapabilityFrameProps): import("react").JSX.Element;

package/dist/components/session-chrome.d.ts

@@ -25,19 +25,29 @@
  *
  * Inbox and queue stay separate segments. Queue hover actions wire to
  * `UseTurnQueueResult` (`editTurn` / `steerTurn` / `moveTurn` / `removeTurn`).
+ * The collapsed queue chip previews the latest queued message beside its Steer
+ * action; open queue rows keep Steer visible and reveal the rest on hover.
  * Inbox has no product dismiss API; pass `onDismissIncoming` when the host
  * wants a visible action (dev harness may use a local dummy).
  *
+ * Queue opens by default when chrome is idle and at least one authoritative
+ * prompt is queued. Closing the queue dismisses that session's offer until
+ * occupancy drains; a different session on the same chrome instance may
+ * offer again. An in-flight optimistic Send never opens the drawer —
+ * admission stays a paint-only receipt on the chip so layout does not jump
+ * under the pointer.
+ *
  * Segment switches keep the panel shell mounted and crossfade content. The
  * shell uses one CSS grid-track transition for deliberate open/close actions;
  * live queue reconciliation never feeds measurements back into layout.
  */
-import type { SessionGoal } from "@opengeni/sdk";
+import type { SessionGoal, SessionStatus } from "@opengeni/sdk";
 import { type ReactNode } from "react";
-import type { ComposerState } from "../hooks/use-composer.js";
+import type { ComposerOptimisticMessage, ComposerState } from "../hooks/use-composer.js";
 import type { UseGoalResult } from "../hooks/use-goal.js";
 import type { UseTurnQueueResult } from "../hooks/use-turn-queue.js";
-export type SessionChromeSignalId = "incoming" | "steering" | "queue" | "goal" | "agents";
+import { countAuthoritativeQueuedTurns } from "../queue-presentation-model.js";
+export type SessionChromeSignalId = "incoming" | "steering" | "queue" | "goal" | "agents" | "commands";
 export type SessionChromeSignalTone = "neutral" | "accent" | "waiting" | "running";
 export type SessionChromeAgentsSignal = {
     count: number;
@@ -45,12 +55,27 @@ export type SessionChromeAgentsSignal = {
     tone?: SessionChromeSignalTone | undefined;
 };
 export type SessionChromeProps = {
+    /** Authoritative execution status; omitted by older embedding hosts. */
+    sessionStatus?: SessionStatus | undefined;
     queue: UseTurnQueueResult;
+    /** Open and focus an existing queued prompt without changing its delivery. */
+    queueFocusTarget?: {
+        turnId: string;
+        requestId: number;
+    } | undefined;
     /** Needed for queue edit → composer checkout. Omit with `readOnly`. */
     composer?: ComposerState | undefined;
+    /** Focus the composer after a successful queue checkout has applied its draft.
+     * Connect to the composer controller's `focusInput`, or a custom input ref.
+     * Never called for failed checkout or while replacement awaits confirmation.
+     */
+    onComposerFocus?: (() => void) | undefined;
     goal?: UseGoalResult | null | undefined;
     /** Expanded agents body (host supplies tree / list). */
     agentsPanel?: ReactNode;
+    /** Active commands only. The host mounts the body only when opened. */
+    commandsPanel?: ReactNode;
+    commandsCount?: number | undefined;
     /** Chip summary; when `count > 0` the agents segment appears. */
     agentsSignal?: SessionChromeAgentsSignal | undefined;
     /**
@@ -58,6 +83,8 @@ export type SessionChromeProps = {
      * (and the gallery) may still pass a handler so the action is visible.
      */
     onDismissIncoming?: ((inputId: string) => void) | undefined;
+    /** Open a typed child update's source through the host's normal authorized route. */
+    onOpenSession?: ((sessionId: string) => void) | undefined;
     readOnly?: boolean | undefined;
     className?: string | undefined;
     /** Controlled active segment; omit for uncontrolled. */
@@ -65,19 +92,41 @@ export type SessionChromeProps = {
     defaultActive?: SessionChromeSignalId | null | undefined;
     onActiveChange?: ((next: SessionChromeSignalId | null) => void) | undefined;
 };
-type GoalPillState = "pursuing" | "waiting" | "scheduled" | "blocked" | "held" | "paused" | "invariant_broken" | "completed";
+type GoalPillState = "pursuing" | "waiting" | "scheduled" | "session_failed" | "blocked" | "held" | "paused" | "invariant_broken" | "completed";
 type GoalPillRecord = Pick<SessionGoal, "status" | "pausedReason"> & {
+    rationale?: SessionGoal["rationale"];
     continuation?: SessionGoal["continuation"] | null | undefined;
 };
 /** Pill label, with the pause reason spelled out: "Paused · cap" / "Paused · manually". */
 export declare function sessionChromeGoalPillLabel(state: GoalPillState, record: GoalPillRecord | null | undefined): string;
 /**
  * One human sentence explaining WHY the goal is not pursuing right now: the
- * pause reason, the agent's own `goal_wait` hold (reason + deadline), or the
+ * pause reason, the agent's own `wait_for_input` hold (reason + deadline), or the
  * next idle-backoff check time. Null when the state needs no explanation.
  */
 export declare function sessionChromeGoalPillExplanation(state: GoalPillState, record: GoalPillRecord | null | undefined): string | null;
+export { countAuthoritativeQueuedTurns };
+export declare function countOptimisticQueuedMessages(messages: readonly ComposerOptimisticMessage[] | undefined, queuedTurnIds: ReadonlySet<string>, snapshot: UseTurnQueueResult["snapshot"]): number;
+/**
+ * First uncontrolled segment. An existing authoritative queue opens itself
+ * when the host did not pick another default; optimistic-only occupancy
+ * stays collapsed so a live Send does not shove a drawer under the pointer.
+ */
+export declare function sessionChromeInitialActive(input: {
+    defaultActive: SessionChromeSignalId | null;
+    authoritativeQueuedCount: number;
+}): SessionChromeSignalId | null;
+/**
+ * Whether idle chrome should offer the queue panel. A dismissed session
+ * stays collapsed until occupancy drains. Controlled hosts own this.
+ */
+export declare function sessionChromeShouldOfferQueue(input: {
+    controlled: boolean;
+    active: SessionChromeSignalId | null;
+    activityOpen: boolean;
+    authoritativeQueuedCount: number;
+    suppressed: boolean;
+}): boolean;
 /** Select pill state from the goal's authoritative continuation projection. */
-export declare function sessionChromeGoalPillState(goalStatus: "active" | "paused" | "completed", continuation: SessionGoal["continuation"] | null | undefined): GoalPillState;
-export declare function SessionChrome({ queue, composer, goal, agentsPanel, agentsSignal, onDismissIncoming, readOnly, className, active: activeControlled, defaultActive, onActiveChange, }: SessionChromeProps): import("react").JSX.Element | null;
-export {};
+export declare function sessionChromeGoalPillState(goalStatus: "active" | "paused" | "completed", continuation: SessionGoal["continuation"] | null | undefined, sessionStatus?: SessionStatus): GoalPillState;
+export declare function SessionChrome({ sessionStatus, queue, queueFocusTarget, composer, onComposerFocus, goal, agentsPanel, commandsPanel, commandsCount, agentsSignal, onDismissIncoming, onOpenSession, readOnly, className, active: activeControlled, defaultActive, onActiveChange, }: SessionChromeProps): import("react").JSX.Element | null;

package/dist/components/session-commands-panel.d.ts

@@ -0,0 +1,6 @@
+import type { UseSessionBackgroundCommandsResult } from "../hooks/use-session-background-commands.js";
+/** The current session's live commands. Settled commands belong to the timeline. */
+export declare function SessionCommandsPanel({ commands: state, readOnly, }: {
+    commands: UseSessionBackgroundCommandsResult;
+    readOnly?: boolean;
+}): import("react").JSX.Element;

package/dist/components/session-commands.d.ts

@@ -0,0 +1,6 @@
+import { type UseSessionBackgroundCommandsOptions } from "../hooks/use-session-background-commands.js";
+/** Mount in the open activity panel so closed chrome never polls commands. */
+export declare function SessionCommands({ sessionId, readOnly, ...options }: UseSessionBackgroundCommandsOptions & {
+    sessionId: string;
+    readOnly?: boolean;
+}): import("react").JSX.Element;

package/dist/components/session-connection-request.d.ts

@@ -0,0 +1,8 @@
+import type { AuthNeededItem } from "../timeline/types.js";
+import { type SessionMcpCapabilityCardProps } from "./session-mcp-capability-card.js";
+export type SessionConnectionRequestProps = Omit<SessionMcpCapabilityCardProps, "capabilityId" | "name" | "rationale"> & {
+    request: AuthNeededItem;
+};
+/** Resolve native reauthorization notices with the same exact-identity rules
+ * as the console. Recommendations never supply endpoints or account authority. */
+export declare function SessionConnectionRequest(props: SessionConnectionRequestProps): import("react").JSX.Element;

package/dist/components/session-conversation.d.ts

@@ -0,0 +1,157 @@
+import { type ClientVoiceInputConfig } from "@opengeni/sdk";
+import { type ComponentProps, type CSSProperties } from "react";
+import type { ClientOverride } from "../session-context.js";
+import { type ModelPolicyPickerProps } from "./model-policy-picker.js";
+import { type SessionConversationController, type UseSessionConversationOptions } from "../hooks/use-session-conversation.js";
+import type { SessionRealtimeControl } from "../realtime/realtime-control.js";
+import { type GenieLoadingOptions } from "../timeline/genie-loading.js";
+import { ApprovalSurface } from "./approval-surface.js";
+import { type ChatComposerProps } from "./chat-composer.js";
+import type { ComposerTranscriptionControlProps } from "./composer-transcription-control.js";
+import { type SessionChromeProps } from "./session-chrome.js";
+import { type HumanInputSurfaceProps } from "./human-input-surface.js";
+import { type MessageTimelineProps } from "./message-timeline.js";
+import { type OpenGeniLinkResolver, type OpenGeniViewerTarget } from "./open-geni-links.js";
+import type { UserMessageDisclosureLabels } from "./user-message-body.js";
+import { type SessionProxyBaseUrl } from "./session-proxy-scope.js";
+import { type HostSurfacePreference, type HostThemePreference } from "../lib/host-theme.js";
+export type SessionConversationLabels = {
+    /** Banner action after a refresh failure; the conversation stays mounted. */
+    retry: string;
+    /** Action when the conversation could not load at all. */
+    tryAgain: string;
+    /** Shown in place of a Site preview when the session proxy does not serve Sites. */
+    sitePreviewUnavailable: string;
+};
+export type SessionConversationProps = ClientOverride & SessionProxyBaseUrl & {
+    sessionId: string;
+    /** Host-owned artifact links, previews and other message presentation. */
+    renderMessageText?: MessageTimelineProps["renderMessageText"];
+    /**
+     * Open Opengeni object links in agent replies (`artifact:`, `sandbox:`,
+     * editable artifacts, Sites). Asked first; by default retained files and
+     * sandbox files download only when the proxy explicitly enables them, while
+     * editable artifacts and Sites stay unavailable until the host resolves them.
+     */
+    resolveLink?: OpenGeniLinkResolver | undefined;
+    /**
+     * Open agent links to editable artifacts and Sites in a host viewer, for
+     * example `SessionArtifactViewer` mounted beside the conversation. Asked
+     * after `resolveLink`.
+     */
+    onOpenArtifact?: ((target: OpenGeniViewerTarget) => void) | undefined;
+    /**
+     * Open another session the conversation points at: a sub-agent's chat from
+     * its worker card or a child update. `OpenGeniChat` opens it in place;
+     * without it those entries are not links.
+     */
+    onOpenSession?: ((sessionId: string) => void) | undefined;
+    /**
+     * Current title for a session id, used to name the agents this
+     * conversation spawns, messages, and hears from. Without it, agents keep
+     * the title they were spawned with, or generic labels.
+     */
+    resolveSessionTitle?: ((sessionId: string) => string | null | undefined) | undefined;
+    /**
+     * Inline previews for assistant `opengeni-site` / `opengeni-html` fences.
+     * Defaults to the Opengeni preview. Behind a session proxy without its
+     * `artifacts` option, Sites show as unavailable without a request; `false`
+     * shows the fence as code.
+     */
+    renderInteractiveBlock?: MessageTimelineProps["renderInteractiveBlock"] | false;
+    /** Product-specific tool-call renderers; defaults to the built-in registry. */
+    toolRegistry?: MessageTimelineProps["toolRegistry"];
+    /** Host presentation without replacing native history, navigation or annotations. */
+    timelineProps?: Pick<MessageTimelineProps, "turnSummary" | "renderAuthNeeded" | "emptyState" | "renderMessageSender"> | undefined;
+    /**
+     * Replace the "usage limit reached" row for an `allowance_exhausted`
+     * refusal, for example to link your own plan or admin page.
+     */
+    renderAllowanceExhausted?: MessageTimelineProps["renderAllowanceExhausted"];
+    /** Replace the words of the default "usage limit reached" row. */
+    allowanceExhaustedLabels?: MessageTimelineProps["allowanceExhaustedLabels"];
+    /**
+     * File attachments in the composer. Defaults to true; the attach control
+     * appears only when the deployment's client config enables file uploads.
+     * A session proxy reports them off when `files` is false and for anonymous
+     * visitors (`visitor: true` from `resolve`) unless it sets `visitorUploads`.
+     */
+    attachments?: boolean | undefined;
+    /**
+     * Composer microphone (dictation into the draft). Defaults to true; it
+     * appears only when the client config reports voice input available
+     * (`createSessionProxyHandler({ voiceInput: false })` turns it off).
+     */
+    voiceInput?: boolean | undefined;
+    /**
+     * Live speech-to-speech voice in the composer. Opt-in: a call spends the
+     * workspace's credits and asks for the microphone, so it is off unless this
+     * is `true` or the client config reports `realtimeVoice: true`
+     * (`createSessionProxyHandler({ realtimeVoice: true })`). The button then
+     * appears only when the workspace offers an available voice model and the
+     * proxy has not turned voice off (`realtimeVoice: false`).
+     */
+    realtimeVoice?: boolean | undefined;
+    /** Optional connection/voice handoff; the stock control owns call lifecycle and admission. */
+    realtimeVoiceProps?: Partial<Pick<ComponentProps<typeof SessionRealtimeControl>, "codexConnected" | "realtimeAutostartModel" | "onRealtimeAutostartConsumed" | "onVoiceActiveChange" | "modelMenu">> | undefined;
+    /**
+     * Copy and visual for the "working" indicator before the first reply.
+     * Defaults to neutral copy ("Thinking…"); omitted fields keep those
+     * defaults. See `MessageTimeline`'s `genieLoading`.
+     */
+    genieLoading?: GenieLoadingOptions | undefined;
+    /**
+     * Show the model/reasoning picker. End users of an embedded product rarely
+     * choose models, so it is hidden unless this is `true` or the client config
+     * reports `modelSelection: true` (`createSessionProxyHandler({ modelSelection: true })`).
+     */
+    modelPicker?: boolean | undefined;
+    /** Model-picker appearance only; visibility, policy and delivery remain owned here. */
+    modelPickerProps?: Pick<ModelPolicyPickerProps, "groupPresentation" | "messages"> | undefined;
+    /** Localized actions for already-sent user-message disclosure. */
+    userMessageDisclosureLabels?: UserMessageDisclosureLabels | undefined;
+    loadSkillReview?: HumanInputSurfaceProps["loadSkillReview"];
+    className?: string;
+    /** Defaults to filling the host. The host owns available height. */
+    height?: CSSProperties["height"];
+    /**
+     * Light or dark. Defaults to `auto`: follow the host page (an enclosing
+     * `data-og-theme`, `class="dark"`/`data-theme` on <html> or <body>, the
+     * host's `color-scheme`, then its background), not the OS setting alone.
+     */
+    theme?: HostThemePreference | undefined;
+    /**
+     * `host` (default) derives backgrounds and cards from the host background so
+     * the conversation blends in; `theme` uses the `--og-color-*` surface tokens
+     * as they are. Customized surface tokens are always kept.
+     */
+    surface?: HostSurfacePreference | undefined;
+    /** Conversation-owned copy (error actions). */
+    labels?: Partial<SessionConversationLabels> | undefined;
+    /** Presentation/custom controls only; queue and delivery wiring stay owned here. */
+    composerProps?: Omit<ChatComposerProps, "composer" | "effectiveControl" | "queuedAheadCount" | "attachments">;
+    /** Optional host context and notifications; stock delivery remains authoritative. */
+    composerOptions?: UseSessionConversationOptions["composerOptions"];
+    /** Extra status panels without replacing stock queue/goal behavior. */
+    chromeProps?: Omit<SessionChromeProps, "queue" | "composer" | "goal" | "sessionStatus" | "readOnly" | "onComposerFocus">;
+    /** Localized questions and presentation; responses remain stock. */
+    humanInputProps?: Pick<HumanInputSurfaceProps, "messages" | "autoFocus" | "decisionButtons" | "allowedSaveTo" | "className">;
+    /** Product approval presentation; permission decisions remain stock. */
+    approvalProps?: Omit<ComponentProps<typeof ApprovalSurface>, "approvals" | "onApprove" | "onReject" | "responding" | "error">;
+};
+export type SessionConversationViewProps = Omit<SessionConversationProps, "sessionId" | "client" | "workspaceId" | "baseUrl" | "headers" | "fetch" | "attachments" | "modelPicker" | "composerOptions"> & {
+    conversation: SessionConversationController;
+};
+/** Complete existing-session conversation. Uses the provider's normal SDK client
+ * (including Site clients), one shared event feed, and authoritative queue state.
+ * `<SessionConversation baseUrl="/api/opengeni" sessionId={id} />` needs no
+ * provider: it talks to your session proxy and its resolved workspace. */
+export declare function SessionConversation({ baseUrl, headers, fetch, ...props }: SessionConversationProps): import("react").JSX.Element;
+/** Stock view for a controller mounted in a stable host. No second event feed or draft. */
+export declare function SessionConversationView(props: SessionConversationViewProps): import("react").JSX.Element;
+/**
+ * The composer microphone: shown when the deployment can transcribe, enabled
+ * once the workspace's voice-input setting allows it.
+ */
+export declare function useComposerTranscription(client: unknown, workspaceId: string, capability: ClientVoiceInputConfig | null): ComposerTranscriptionControlProps | null;
+export { useClientConfigFlags } from "../hooks/use-client-config-flags.js";

package/dist/components/session-list.d.ts

@@ -0,0 +1,39 @@
+import { type ClientOverride } from "../session-context.js";
+export type SessionListLabels = {
+    heading: string;
+    newChat: string;
+    empty: string;
+    loading: string;
+    loadMore: string;
+    rename: string;
+    archive: string;
+    save: string;
+    cancel: string;
+};
+export type SessionListProps = ClientOverride & {
+    selectedSessionId?: string | null | undefined;
+    onSelect: (sessionId: string) => void;
+    /** Shown as a "New chat" button when provided. */
+    onNewChat?: (() => void) | undefined;
+    /** Allow inline rename (`updateSession`). Defaults to true. */
+    rename?: boolean | undefined;
+    /**
+     * Allow archiving (`updateSessionArchive`). Defaults to true; hidden when the
+     * session proxy reports archive disabled (`archive: false`).
+     */
+    archive?: boolean | undefined;
+    /** Called after the selected chat was archived, so the host can move on. */
+    onArchived?: ((sessionId: string) => void) | undefined;
+    pageSize?: number | undefined;
+    /** Change the reference to force a refetch (for example after creating a chat). */
+    refreshKey?: unknown;
+    labels?: Partial<SessionListLabels> | undefined;
+    className?: string | undefined;
+};
+/**
+ * The workspace's root chats for the current user, newest activity first.
+ * Through `createSessionProxyHandler` the list is limited to the chats the
+ * resolved user created (or everything they may read, with `sessionList:
+ * "visible"`); Opengeni enforces visibility either way.
+ */
+export declare function SessionList({ client, workspaceId, selectedSessionId, onSelect, onNewChat, rename, archive, onArchived, pageSize, refreshKey, labels: labelOverrides, className, }: SessionListProps): import("react").JSX.Element;

package/dist/components/session-mcp-capability-card.d.ts

@@ -0,0 +1,41 @@
+import type { OpenGeniBrowserClient as OpenGeniClient } from "@opengeni/sdk/browser";
+export type SessionMcpCapabilityCardProps = {
+    client: OpenGeniClient;
+    workspaceId: string;
+    sessionId: string;
+    capabilityId: string;
+    name: string;
+    rationale?: string;
+    /** Exact host route; no console-specific routing is assumed. */
+    returnUrl: string;
+    onConfigured?: (() => void | Promise<void>) | undefined;
+};
+export type McpConnectionCardProps = Omit<SessionMcpCapabilityCardProps, "sessionId"> & {
+    /** Omit for connection management: no session tool selection is written. */
+    sessionId?: string;
+    dialogOnly?: boolean;
+    onClose?: (() => void) | undefined;
+    /**
+     * The provider only ever connects someone's own account (official Gmail,
+     * Slack's hosted MCP): no ownership choice, always personal.
+     */
+    personalOnly?: boolean;
+    /** The connect button's words, "Connect Gmail". Defaults to "Continue to <name>". */
+    connectLabel?: string;
+    /** The line under the dialog title. Defaults to the kind and provider domain. */
+    dialogSubtitle?: string;
+    /** The host's product copy for this connection, instead of the catalog description. */
+    description?: string;
+    /** The host's logo for this connection, when the catalog has no asset. */
+    logoSrc?: string | null;
+    /** The host's words for the ownership choice. */
+    ownershipCopy?: {
+        legend: string;
+        workspace: string;
+        personal: string;
+    };
+};
+/** Native OAuth recommendation flow. Identity and endpoint come from the live
+ * catalog, never from model-authored recommendation text. */
+export declare function SessionMcpCapabilityCard(props: SessionMcpCapabilityCardProps): import("react").JSX.Element;
+export declare function McpConnectionCard(props: McpConnectionCardProps): import("react").JSX.Element;

package/dist/components/session-proxy-scope.d.ts

@@ -0,0 +1,35 @@
+import { type FetchLike } from "@opengeni/sdk/browser";
+import { type ReactNode } from "react";
+import type { SessionClientLike } from "../client.js";
+/** Request headers for every proxy call: static, or computed per request. */
+export type SessionProxyHeaders = Record<string, string> | (() => Record<string, string>);
+export type SessionProxyBaseUrl = {
+    /**
+     * Mount path of your `createSessionProxyHandler` (for example
+     * `"/api/opengeni"`). The component then needs no `OpenGeniProvider`,
+     * client, or workspace id: it creates the browser client for that path and
+     * uses the workspace the proxy resolved for the signed-in user. An explicit
+     * `workspaceId` skips that lookup. A `client` you pass is used instead of
+     * the created one (point it at the same proxy).
+     */
+    baseUrl?: string | undefined;
+    /**
+     * `baseUrl` mode: headers added to every proxy request, for hosts that
+     * authenticate with a bearer token instead of cookies. A function is called
+     * per request, so it can return the current token.
+     */
+    headers?: SessionProxyHeaders | undefined;
+    /** `baseUrl` mode: custom fetch for every proxy request (async auth, retries). */
+    fetch?: FetchLike | undefined;
+};
+/**
+ * `OpenGeniProvider` for a same-origin session proxy, from its base URL alone.
+ * The proxy's client config names the resolved workspace, so the browser
+ * never handles an Opengeni id. Provider-based usage is unchanged.
+ */
+export declare function SessionProxyScope({ baseUrl, workspaceId, client: suppliedClient, headers, fetch, children, }: Omit<SessionProxyBaseUrl, "baseUrl"> & {
+    baseUrl: string;
+    workspaceId?: string | undefined;
+    client?: SessionClientLike | undefined;
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/components/session-status.d.ts

@@ -1,4 +1,6 @@
-import type { SessionStatus as SessionStatusValue } from "@opengeni/sdk";
+import { type SessionDisplayStatus } from "../session-status-model.js";
+/** A server status, or the display-only `blocked` (see `sessionDisplayStatus`). */
+type SessionStatusValue = SessionDisplayStatus;
 export type SessionStatusMeta = {
     label: string;
     /** Token-backed color classes for the dot and tinted badge. */
@@ -23,3 +25,4 @@ export type StatusDotProps = {
 };
 /** Just the dot — for dense rows and tiles. */
 export declare function StatusDot({ status, className }: StatusDotProps): import("react").JSX.Element;
+export {};