@opengeni/react 3.3.2 → 3.4.0

package/dist/components/markdown.d.ts

@@ -1,3 +1,6 @@
+import { type ReactNode } from "react";
+import { type TimelineSearchTarget } from "./timeline-search.js";
+import { type OpenGeniLinkResolver } from "./open-geni-links.js";
 /**
  * The default renderer for chat message bodies in {@link MessageTimeline}.
  *
@@ -12,9 +15,33 @@
  * the tokens land. Consumers who want a different renderer can still pass
  * `renderMessageText` to `MessageTimeline` to override this entirely.
  */
+export type MarkdownInteractiveBlock = {
+    kind: "html" | "site";
+    content: string;
+};
 export type MarkdownProps = {
+    /** Resolve a retained-file reference to the host's authenticated artifact page. */
+    artifactHref?: ((artifactId: string) => string) | undefined;
+    /** Reveals a bounded source excerpt; closing Find retains it until explicit restore. */
+    searchTarget?: TimelineSearchTarget | null | undefined;
+    renderImage?: ((image: {
+        src: string;
+        alt: string;
+    }) => ReactNode) | undefined;
+    /** Show alt text without loading image URLs (e.g. in search previews). */
+    suppressImages?: boolean | undefined;
+    /** Host opt-in for assistant-authored interactive fences. */
+    renderInteractiveBlock?: ((block: MarkdownInteractiveBlock) => ReactNode) | undefined;
     children: string;
     className?: string | undefined;
+    /**
+     * Render a single newline inside prose as a line break (`<br>`), the way chat
+     * apps show messages; CommonMark otherwise folds it into a space. Chat message
+     * bodies enable this. Leave it off for documents and other authored Markdown.
+     * Code (fenced and inline), lists, tables, and blank-line paragraphs are
+     * unaffected either way.
+     */
+    softLineBreaks?: boolean | undefined;
     /**
      * While true, newly arrived source fades in through tip ink (`.og-stream-ink`):
      * an age window over each append batch — fast streams keep a large soft band,
@@ -29,6 +56,13 @@ export type MarkdownProps = {
      * exact decoded `sandbox:` payload; `line`, when present, is 1-based.
      */
     onSandboxFile?: ((path: string, line?: number) => void | Promise<void>) | undefined;
+    /**
+     * Resolve Opengeni object links (`artifact:`, `sandbox:`, editable
+     * artifacts, Sites) to a host URL or action. Asked before any
+     * {@link OpenGeniLinkProvider} above this body; `artifactHref` and
+     * `onSandboxFile` still win for their own kinds.
+     */
+    resolveLink?: OpenGeniLinkResolver | undefined;
 };
 /** Exact target path plus optional 1-based line from a markdown href. */
 export type SandboxFileLocation = {
@@ -36,7 +70,7 @@ export type SandboxFileLocation = {
     line: number | null;
 };
 /**
- * Parse an OpenGeni `sandbox:` application href (plus the historical bare
+ * Parse an Opengeni `sandbox:` application href (plus the historical bare
  * `/workspace/...` form). The decoded path is intentionally opaque here:
  * target selection, path policy, and filesystem authority belong to the
  * session-aware host and its FileSystem boundary.
@@ -44,7 +78,6 @@ export type SandboxFileLocation = {
 export declare function sandboxFileLocationFromHref(href: string | undefined): SandboxFileLocation | null;
 /** Return the exact decoded path for a supported sandbox-link href. */
 export declare function sandboxFilePathFromHref(href: string | undefined): string | null;
-declare function MarkdownImpl({ children, className, streaming, onSandboxFile }: MarkdownProps): import("react").JSX.Element;
+export declare function retainedImageId(src: string): string | null;
 /** Memoized so streaming re-renders of the parent don't re-parse settled bodies. */
-export declare const Markdown: import("react").MemoExoticComponent<typeof MarkdownImpl>;
-export {};
+export declare const Markdown: import("react").MemoExoticComponent<(props: MarkdownProps) => import("react").JSX.Element>;

package/dist/components/message-timeline.d.ts

@@ -1,24 +1,65 @@
+import { type TimelineSearchTarget } from "./timeline-search.js";
+import { type GenieLoadingOptions } from "../timeline/genie-loading.js";
 import type { DraftTimelineAnnotation, SessionEvent, SessionStatus } from "@opengeni/sdk";
 import { type ReactNode } from "react";
+import { type RenderMessageSender } from "../timeline/message-sender.js";
 import { type OlderHistoryLoader } from "../older-history.js";
+import { type MarkdownProps } from "./markdown.js";
+import { type OpenGeniLinkResolver } from "./open-geni-links.js";
+import { type UserMessageDisclosureLabels } from "./user-message-body.js";
 import { type AgentMessageItem, type AuthNeededItem, type TimelineGroup, type TimelineItem, type RetainedArtifactLoader, type RetainedScreenshotLoader, type VideoArtifactPlaybackLoader, type ToolRegistry, type TurnSummaryOptions, type UserMessageItem } from "../timeline/index.js";
+import { type ResolveSessionTitle } from "../timeline/agent-identity.js";
+import { type RenderAllowanceExhausted } from "../timeline/allowance-exhausted-row.js";
+import type { AllowanceLabels } from "../usage/allowance-copy.js";
 export type MessageTimelineProps = {
+    /** Exact durable search hit; clearing it removes highlighting without moving the reader. */
+    searchTarget?: TimelineSearchTarget | null | undefined;
+    /**
+     * A durable event sequence to open on once (an inbox item's or notification's
+     * moment): the timeline lands on the row that holds it, or the nearest row
+     * before it, instead of the latest message. Load the window around it first.
+     */
+    focusSequence?: number | null | undefined;
+    /** Localized user-message disclosure actions, including custom UserMessageBody renderers. */
+    userMessageDisclosureLabels?: UserMessageDisclosureLabels | undefined;
     /** Raw session events (projected internally) … */
     events?: SessionEvent[] | undefined;
     /** … or pre-projected items (e.g. from `useSessionEvents().timeline`). */
     items?: TimelineItem[] | undefined;
     /** Current session status (reserved; tip "Working…" chrome removed for now). */
     status?: SessionStatus | null | undefined;
+    /** Host-owned controls beside Copy and the timestamp on settled message rows. */
+    renderMessageActions?: ((item: AgentMessageItem | UserMessageItem) => ReactNode) | undefined;
+    /**
+     * Who sent a person's message, drawn above its bubble. Called only for
+     * messages that carry a sender; return null for the viewer's own messages
+     * or when the host has no identity to show. Omit to show no senders.
+     */
+    renderMessageSender?: RenderMessageSender | undefined;
     /** Plug a markdown renderer for message bodies (e.g. streamdown). */
-    renderMessageText?: ((text: string, item: AgentMessageItem | UserMessageItem) => ReactNode) | undefined;
+    renderMessageText?: ((text: string, item: AgentMessageItem | UserMessageItem, context: {
+        searchTarget: TimelineSearchTarget | null;
+    }) => ReactNode) | undefined;
+    /**
+     * Render assistant `opengeni-html` / `opengeni-site` fences in the default
+     * message renderer (`SessionConversation` supplies the inline Site preview).
+     */
+    renderInteractiveBlock?: MarkdownProps["renderInteractiveBlock"];
     /** Drill into a spawned worker session. */
     onOpenSession?: ((sessionId: string) => void) | undefined;
+    /**
+     * Name the agents this session spawns, messages, and hears from. Return the
+     * current display title for a session id, or null when unknown; the
+     * timeline falls back to the title given at spawn, then to generic copy.
+     * Keep the function identity stable across renders.
+     */
+    resolveSessionTitle?: ResolveSessionTitle | undefined;
     /**
      * Deep-link a memory row (a `memory.saved` / `memory.corrected` step) to its
      * record in the host's memory pane. Opt-in, exactly like `onReconnect`: the
      * library draws no "View in memory" affordance without a handler — the memory
      * row is then non-interactive rich content. This is the switch that makes the
-     * deep-link a first-party OpenGeni capability without other SDK consumers
+     * deep-link a first-party Opengeni capability without other SDK consumers
      * opting into it. The app supplies it (it owns routing to the memory pane).
      */
     onMemoryClick?: ((memoryId: string) => void) | undefined;
@@ -30,6 +71,17 @@ export type MessageTimelineProps = {
      * a Reconnect button without a handler to run it.
      */
     onReconnect?: ((item: AuthNeededItem) => void | Promise<void>) | undefined;
+    /** Host-owned inline connection setup. Return undefined to use the default recovery card. */
+    renderAuthNeeded?: ((item: AuthNeededItem) => ReactNode | undefined) | undefined;
+    /**
+     * Replace the "usage limit reached" row shown when a workspace or member
+     * usage allowance stops work (an `allowance_exhausted` refusal). Receives the
+     * typed refusal (scope, reset time) and the default row; return undefined to
+     * keep the default. Use it to point people at your own plan or admin page.
+     */
+    renderAllowanceExhausted?: RenderAllowanceExhausted | undefined;
+    /** Replace the words of the default "usage limit reached" row. */
+    allowanceExhaustedLabels?: Partial<AllowanceLabels> | undefined;
     /**
      * Decide which durable authentication notices this timeline presents.
      * Defaults to showing every notice. Embedded hosts can suppress notices for
@@ -50,6 +102,16 @@ export type MessageTimelineProps = {
      * `createDefaultToolRegistry({ entries })` to add custom tool renderers.
      */
     toolRegistry?: ToolRegistry | undefined;
+    /**
+     * Open Opengeni object links the agent writes in replies and progress notes:
+     * `artifact:<file>`, `sandbox:<path>`, editable artifacts, and Sites. Return
+     * a host URL (`{ href }`) or action (`{ open }`); unhandled targets render as
+     * unavailable text instead of a console link that 404s inside the host.
+     * Applies to the default message renderer and to any `Markdown` a custom
+     * `renderMessageText` renders. `SessionConversation` supplies file and
+     * sandbox downloads by default.
+     */
+    resolveLink?: OpenGeniLinkResolver | undefined;
     /** Resolve opaque retained screenshot receipts through the authenticated host SDK. */
     loadRetainedScreenshot?: RetainedScreenshotLoader | undefined;
     /** Resolve permanent workspace image/file receipts through the authenticated host SDK. */
@@ -62,11 +124,22 @@ export type MessageTimelineProps = {
      */
     computeLabel?: string | null | undefined;
     /** Customize collapsed turn facets for this timeline instance. */
+    genieLoading?: GenieLoadingOptions | undefined;
     turnSummary?: TurnSummaryOptions | undefined;
     /** Follow new events when pinned to the bottom. Defaults to true. */
     autoFollow?: boolean | undefined;
     /** Capture a same-row text selection into the host's canonical composer draft. */
     onAnnotate?: ((annotation: DraftTimelineAnnotation) => void) | undefined;
+    /**
+     * Hide the floating "Back to your message" pill while the timeline viewport
+     * is shorter than this (px), e.g. a narrow embed above a decision card.
+     * Defaults to 0 (always available).
+     */
+    questionNavMinViewportHeight?: number | undefined;
+    /** Composer draft quotes currently attached to the next send. */
+    draftAnnotations?: readonly DraftTimelineAnnotation[] | undefined;
+    /** Open the composer review list for one numbered draft badge. */
+    onDraftAnnotationSelect?: ((id: string) => void) | undefined;
     /** Older durable history exists above the current window (see useSessionEvents). */
     hasOlder?: boolean | undefined;
     /** An older window is being fetched; shows the quiet top shimmer. */
@@ -85,13 +158,16 @@ export type MessageTimelineProps = {
     hasNewer?: boolean | undefined;
     /** A newer history page is being fetched. */
     loadingNewer?: boolean | undefined;
-    /** Page forward through history without loading the whole gap to the tip. */
-    onLoadNewer?: (() => void) | undefined;
+    /** Page forward through history. Return the request promise to enable inline error/retry. */
+    onLoadNewer?: (() => unknown) | undefined;
     /**
      * Reload the live tip window. When omitted, Jump to latest only re-pins and
      * scrolls the in-memory window.
      */
     onJumpToLatest?: (() => void | Promise<void>) | undefined;
+    /** @deprecated Retained for source compatibility; contextual prompt navigation
+     * uses only mounted prompts and never invokes this global resolver. */
+    onJumpToLatestQuestion?: (() => Promise<number | null>) | undefined;
     /** Host-owned content appended after timeline groups, such as startup progress. */
     trailingState?: ReactNode | undefined;
     emptyState?: ReactNode | undefined;
@@ -103,7 +179,7 @@ export type MessageTimelineProps = {
  * cards, goal markers, and status transitions. Owns stick-to-bottom scrolling
  * with a "jump to latest" affordance when the reader scrolls back.
  */
-export declare function MessageTimeline({ events, items, status: _status, renderMessageText, onOpenSession, onMemoryClick, onReconnect, shouldRenderAuthNeeded, resolveProviderLogo, toolRegistry, loadRetainedScreenshot, loadRetainedArtifact, loadVideoArtifactPlayback, computeLabel, turnSummary, autoFollow, onAnnotate, hasOlder, loadingOlder, onLoadOlder, onJumpToStart, loadingOldest, hasNewer, loadingNewer, onLoadNewer, onJumpToLatest, trailingState, emptyState, className, }: MessageTimelineProps): import("react").JSX.Element;
+export declare function MessageTimeline({ resolveLink, renderInteractiveBlock, userMessageDisclosureLabels, searchTarget, focusSequence, events, items, status: _status, renderMessageActions, renderMessageSender, renderMessageText, onOpenSession, resolveSessionTitle, onMemoryClick, onReconnect, renderAuthNeeded, renderAllowanceExhausted, allowanceExhaustedLabels, shouldRenderAuthNeeded, resolveProviderLogo, toolRegistry, loadRetainedScreenshot, loadRetainedArtifact, loadVideoArtifactPlayback, computeLabel, genieLoading, turnSummary, autoFollow, onAnnotate, questionNavMinViewportHeight, draftAnnotations, onDraftAnnotationSelect, hasOlder, loadingOlder, onLoadOlder, onJumpToStart, loadingOldest, hasNewer, loadingNewer, onLoadNewer, onJumpToLatest, trailingState, emptyState, className, }: MessageTimelineProps): import("react").JSX.Element;
 /**
  * Settled turns lift the final agent answer out as a sibling group. Include it
  * in "Copy turn" when present so the chip copies the full assistant reply.
@@ -115,11 +191,14 @@ export declare function trailingAgentTextAfterTurn(group: TimelineGroup, next: T
  * landmark, notice). Exported so the component demo draws the EXACT same rows as
  * the live app — no forked bubble/goal markup.
  */
-export declare function TimelineRow({ item, renderMessageText, onReconnect, resolveProviderLogo, onOpenSession, loadVideoArtifactPlayback, }: {
+export declare function TimelineRow({ item, renderMessageActions, renderMessageText, onReconnect, renderAuthNeeded, resolveProviderLogo, onOpenSession, loadVideoArtifactPlayback, }: {
     item: TimelineItem;
+    renderMessageActions?: ((item: AgentMessageItem | UserMessageItem) => ReactNode) | undefined;
     renderMessageText?: ((text: string, item: AgentMessageItem | UserMessageItem) => ReactNode) | undefined;
     onReconnect?: ((item: AuthNeededItem) => void | Promise<void>) | undefined;
+    /** Host-owned inline connection setup. Return undefined to use the default recovery card. */
+    renderAuthNeeded?: ((item: AuthNeededItem) => ReactNode | undefined) | undefined;
     resolveProviderLogo?: ((providerDomain: string) => string | null | undefined) | undefined;
     onOpenSession?: ((sessionId: string) => void) | undefined;
     loadVideoArtifactPlayback?: VideoArtifactPlaybackLoader | undefined;
-}): import("react").JSX.Element | null;
+}): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | Iterable<ReactNode> | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | import("react").ReactPortal | null | undefined> | null;

package/dist/components/model-mark.d.ts

@@ -0,0 +1,29 @@
+import { type ModelDisplayInput } from "@opengeni/sdk/model-display";
+import { type ReactNode, type SVGProps } from "react";
+/** ChatGPT / OpenAI mark (Simple Icons path), currentColor like the other marks. */
+export declare function ChatGptMark(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;
+/** True when `ModelMark` has a real maker logo for this model (not the neutral fallback). */
+export declare function modelHasMark(model: ModelDisplayInput): boolean;
+/**
+ * The catalog's maker logo, with bundled maker logos and a neutral fallback.
+ * Makers without a configured or bundled logo get a neutral mark, so an org- and
+ * a workspace-connected copy of one model always look the same.
+ */
+export declare function ModelMark(props: {
+    model: ModelDisplayInput;
+    className?: string | undefined;
+    /** Shown when the maker has no bundled logo. Defaults to a neutral sparkle. */
+    fallback?: ReactNode;
+    "aria-label"?: string | undefined;
+}): import("react").JSX.Element | null;
+/**
+ * A model as people should see it outside model settings: the maker's mark and
+ * the clean display name. Never a routing prefix, connection id or scope.
+ */
+export declare function ModelName(props: {
+    model: ModelDisplayInput;
+    /** Hide the maker mark for dense text-only contexts. */
+    mark?: boolean | undefined;
+    className?: string | undefined;
+    markClassName?: string | undefined;
+}): import("react").JSX.Element;

package/dist/components/model-policy-picker-menu.d.ts

@@ -0,0 +1,9 @@
+import { type RefObject, type CSSProperties } from "react";
+import { type ModelPolicyPickerProps } from "./model-policy-picker.js";
+/** Model selection stays flat; reasoning never becomes a navigation destination. */
+export declare function ModelPolicyPickerMenu(props: ModelPolicyPickerProps): import("react").JSX.Element;
+export declare function ModelPolicyPickerPopover(props: ModelPolicyPickerProps & {
+    anchor: RefObject<HTMLButtonElement | null>;
+    contentId: string;
+    portalStyle: CSSProperties;
+}): import("react").JSX.Element;

package/dist/components/model-policy-picker.d.ts

@@ -1,28 +1,19 @@
 import type { ClientModel, LatencyMode, ReasoningEffort } from "@opengeni/sdk";
 import { type CSSProperties, type ReactNode } from "react";
+import { defaultModelPolicyPickerMessages, groupPresentationFor, SCOPED_BILLING_HINTS, type ModelPickerGroupPresentation, type ModelPolicyPickerMessages } from "../model-picker-model.js";
 import { type PickerBillingClass, type PickerModelRow } from "../model-policy.js";
 type ClientPickerModelRow = PickerModelRow<ClientModel>;
-type NavLevel = "providers" | "models" | "thinking";
-type PickerNavState = {
-    level: NavLevel;
-    rail: PickerBillingClass | null;
-    modelId: string | null;
-};
-type NavUpdater = PickerNavState | ((previous: PickerNavState) => PickerNavState);
-export type ModelPolicyPickerMessages = {
-    label: string;
-    loading: string;
-    noModels: string;
-    thinking: string;
-    fast: string;
-    fastRateHint: string;
-    codexOnly: string;
-    billingHints: Record<PickerBillingClass, string>;
-};
-export declare const defaultModelPolicyPickerMessages: ModelPolicyPickerMessages;
+/** Presentation only; never changes model identity, billing or availability. */
+export type ModelPolicyPickerGroupPresentation = ModelPickerGroupPresentation<ReactNode>;
+export { defaultModelPolicyPickerMessages, groupPresentationFor, SCOPED_BILLING_HINTS };
+export type { ModelPolicyPickerMessages };
 export type ModelPolicyPickerProps = {
+    /** Host branding for payment-source groups, shared by menu and trigger. */
+    groupPresentation?: ModelPolicyPickerGroupPresentation | undefined;
     /** Lightweight deployment models. Catalog rows take precedence when supplied. */
     models?: ClientModel[] | undefined;
+    /** Warn only when the draft actually contains images this model cannot view. */
+    hasImageAttachments?: boolean | undefined;
     /** Catalog-backed rows with availability and billing-class truth. */
     rows?: PickerModelRow[] | undefined;
     model: string;
@@ -38,17 +29,37 @@ export type ModelPolicyPickerProps = {
     onOpenChange?: ((open: boolean) => void) | undefined;
     /** Non-Codex models stay visible but cannot be selected. */
     codexOnly?: boolean | undefined;
-    /** Resets drill-down navigation when the session scope changes. */
+    /** Identity of the current session scope. */
     sessionKey?: string | undefined;
     /** Prefer bottom on new-chat surfaces and top for bottom-docked composers. */
     menuSide?: "top" | "bottom" | undefined;
+    /**
+     * Default true: show models the way people choose them, with clean names,
+     * maker marks, one "API keys" group for organization- and workspace-connected
+     * keys, and one row for identical copies. Models settings passes false to
+     * keep its scope-aware presentation (raw catalog labels, scoped groups).
+     */
+    collapseScopes?: boolean | undefined;
     /** Hide latency controls on surfaces whose saved policy does not include latency. */
     allowLatencyMode?: boolean | undefined;
+    /** Hide effort and latency controls when the saved policy chooses only a model identity. */
+    allowModelOptions?: boolean | undefined;
+    /** Settings → Models. Shown when the catalog has no model that can run. */
+    connectModelsHref?: string | undefined;
     /** Classes for the portalled menu surface. Prefer --og-* tokens for theming. */
     contentClassName?: string | undefined;
     /** Inline styles for the portalled menu, applied after inherited --og-* tokens. */
     contentStyle?: CSSProperties | undefined;
     className?: string | undefined;
+    /**
+     * "pill" (default) is the composer's quiet rounded trigger with the effort.
+     * "field" is a settings control: a bordered rectangle with the model name
+     * and `triggerMeta` (for example the payer) in muted text. The effort stays
+     * in the menu.
+     */
+    triggerStyle?: "pill" | "field" | undefined;
+    /** Muted text after the model name in the "field" trigger. */
+    triggerMeta?: ReactNode;
     messages?: Partial<ModelPolicyPickerMessages> | undefined;
     onModelChange: (modelId: string) => void;
     onEffortChange: (effort: ReasoningEffort) => void;
@@ -56,9 +67,11 @@ export type ModelPolicyPickerProps = {
 };
 export declare function BillingClassMark(props: {
     billingClass: PickerBillingClass;
+    presentation?: ModelPolicyPickerGroupPresentation[PickerBillingClass] | undefined;
     className?: string | undefined;
     "aria-label"?: string | undefined;
-}): import("react").JSX.Element;
+}): import("react").JSX.Element | null;
+export declare function effectiveRows(props: ModelPolicyPickerProps): ClientPickerModelRow[];
 export declare function PickerNavRow(props: {
     label: string;
     hint?: string | undefined;
@@ -67,6 +80,7 @@ export declare function PickerNavRow(props: {
     showChevron?: boolean | undefined;
     disabled?: boolean | undefined;
     title?: string | undefined;
+    description?: string | undefined;
     active?: boolean | undefined;
     testId?: string | undefined;
     onClick: () => void;
@@ -82,17 +96,10 @@ export declare function PickerAnimatedPage(props: {
     direction: 1 | -1;
     children: ReactNode;
 }): import("react").JSX.Element;
-export declare function ModelPolicyPickerMenu(props: ModelPolicyPickerProps & {
-    nav?: PickerNavState | undefined;
-    onNavChange?: ((next: NavUpdater) => void) | undefined;
-}): import("react").JSX.Element;
-/** @internal Shared state seam kept outside the Radix portal for deterministic testing. */
+/** @internal Shared controlled/uncontrolled state seam. */
 export declare function useModelPolicyPickerState(props: ModelPolicyPickerProps): {
     open: boolean;
     setOpen: (next: boolean) => void;
     rows: ClientPickerModelRow[];
-    nav: PickerNavState;
-    setNav: (next: NavUpdater) => void;
 };
 export declare function ModelPolicyPicker(props: ModelPolicyPickerProps): import("react").JSX.Element;
-export {};

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

@@ -0,0 +1,32 @@
+import { type NewConversationController, type UseNewConversationOptions } from "../hooks/use-new-conversation.js";
+import { type SessionConversationProps } from "./session-conversation.js";
+import { type SessionProxyBaseUrl } from "./session-proxy-scope.js";
+export type NewConversationLabels = {
+    title: string;
+    placeholder: string;
+    send: string;
+    unavailable: string;
+    retry: string;
+    pending: string;
+    finishingUploads: string;
+};
+type Presentation = {
+    composerProps?: SessionConversationProps["composerProps"] | undefined;
+    modelPickerProps?: SessionConversationProps["modelPickerProps"] | undefined;
+    voiceInput?: boolean | undefined;
+    realtimeVoiceProps?: SessionConversationProps["realtimeVoiceProps"] | undefined;
+    labels?: Partial<NewConversationLabels> | undefined;
+    theme?: SessionConversationProps["theme"] | undefined;
+    surface?: SessionConversationProps["surface"] | undefined;
+    height?: SessionConversationProps["height"] | undefined;
+    className?: string | undefined;
+};
+export type NewConversationProps = UseNewConversationOptions & SessionProxyBaseUrl & Presentation;
+export type NewConversationViewProps = Presentation & {
+    creation: NewConversationController;
+};
+/** Standalone stock new-chat composer. OpenGeniChat uses this same implementation. */
+export declare function NewConversation({ baseUrl, headers, fetch, ...props }: NewConversationProps): import("react").JSX.Element;
+/** Presentation for a new-chat controller kept above host layout changes. */
+export declare function NewConversationView({ creation, labels: overrides, composerProps, modelPickerProps, voiceInput, realtimeVoiceProps, theme, surface, height, className, }: NewConversationViewProps): import("react").JSX.Element;
+export {};

package/dist/components/open-geni-chat.d.ts

@@ -0,0 +1,73 @@
+import { type CSSProperties } from "react";
+import type { NewConversationCreateOptions } from "../hooks/use-new-conversation.js";
+import { type HostSurfacePreference, type HostThemePreference } from "../lib/host-theme.js";
+import { type ClientOverride } from "../session-context.js";
+import { type SessionConversationProps } from "./session-conversation.js";
+import { type SessionListLabels, type SessionListProps } from "./session-list.js";
+import { type SessionProxyBaseUrl } from "./session-proxy-scope.js";
+export type OpenGeniChatLabels = SessionListLabels & {
+    openChats: string;
+    closeChats: string;
+    newChatPlaceholder: string;
+    /** Heading above the new-chat composer; empty hides it. */
+    newChatTitle: string;
+    send: string;
+    newChatUnavailable: string;
+    newChatRetry?: string | undefined;
+    newChatPending?: string | undefined;
+    newChatFinishingUploads?: string | undefined;
+};
+/** What the first message carries besides its text. */
+export type OpenGeniChatCreateOptions = NewConversationCreateOptions;
+export type OpenGeniChatProps = ClientOverride & SessionProxyBaseUrl & {
+    /** Controlled selection. `null` shows the new-chat composer. */
+    sessionId?: string | null | undefined;
+    /** Initial selection when uncontrolled. Defaults to a new chat. */
+    defaultSessionId?: string | null | undefined;
+    onSessionChange?: ((sessionId: string | null) => void) | undefined;
+    /**
+     * Create a chat from its first message. Defaults to `client.createSession`
+     * with `{ initialMessage, idempotencyKey }` plus the attached files and any
+     * model choice, which `createSessionProxyHandler` accepts when the server
+     * supplies a `createSession` hook. Return the new id.
+     */
+    createSession?: ((initialMessage: string, idempotencyKey: string, options: OpenGeniChatCreateOptions) => Promise<string>) | undefined;
+    /**
+     * Hide the "New chat" entry point. It is also hidden when the session proxy
+     * reports chat creation unavailable (no `createSession` hook) and no
+     * `createSession` prop is given.
+     */
+    newChat?: boolean | undefined;
+    /**
+     * Forwarded to the conversation (message rendering, tool renderers,
+     * composer...). `attachments`, `modelPicker`, `modelPickerProps`, and
+     * `composerProps` also apply to the new-chat composer.
+     */
+    conversationProps?: Omit<SessionConversationProps, "sessionId" | "client" | "workspaceId" | "baseUrl" | "headers" | "fetch">;
+    /** Forwarded to the list (rename/archive toggles, page size). */
+    listProps?: Pick<SessionListProps, "rename" | "archive" | "pageSize"> | undefined;
+    labels?: Partial<OpenGeniChatLabels> | undefined;
+    className?: string | undefined;
+    /** Defaults to filling the host. */
+    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 chat blends in; `theme` uses the `--og-color-*` surface tokens as they
+     * are. Customized surface tokens are always kept.
+     */
+    surface?: HostSurfacePreference | undefined;
+};
+/**
+ * A complete chat experience: the user's chat list plus the conversation.
+ * The list is a sidebar when the component is wide and a drawer when narrow
+ * (container-based, so it adapts inside panels as well as full pages).
+ * `<OpenGeniChat baseUrl="/api/opengeni" />` needs no provider: it talks to
+ * your session proxy and uses the workspace the proxy resolves.
+ */
+export declare function OpenGeniChat({ baseUrl, headers, fetch, ...props }: OpenGeniChatProps): import("react").JSX.Element;

package/dist/components/open-geni-links.d.ts

@@ -0,0 +1,68 @@
+import type { OpenGeniClient, OpenGeniLinkTarget } from "@opengeni/sdk";
+import { type ReactNode } from "react";
+export type { OpenGeniLinkTarget };
+/**
+ * How the host opens one Opengeni object an agent linked in chat Markdown.
+ *
+ * - `{ href }` renders a real link (new tab) — use it for a host page URL.
+ * - `{ open }` renders a button that runs the action (download, open a panel,
+ *   client-side navigation) with loading and retry states.
+ * - `null` / `undefined` means "not handled here": the next resolver is asked,
+ *   and when none handles it the text renders as an unavailable reference —
+ *   never as a navigation that would 404 inside the host.
+ */
+export type OpenGeniLinkResolution = {
+    href: string;
+    open?: undefined;
+} | {
+    open: () => void | Promise<void>;
+    href?: undefined;
+};
+export type OpenGeniLinkResolver = (target: OpenGeniLinkTarget) => OpenGeniLinkResolution | null | undefined;
+/** First resolver that handles a target wins. */
+export declare function chainLinkResolvers(...resolvers: ReadonlyArray<OpenGeniLinkResolver | null | undefined>): OpenGeniLinkResolver | null;
+/**
+ * Resolve Opengeni object links (`artifact:`, `sandbox:`, editable artifacts,
+ * Sites) for every {@link Markdown} body below. An inner provider is asked
+ * before an outer one, so a host can override a single kind and keep defaults.
+ */
+export declare function OpenGeniLinkProvider({ resolveLink, children, }: {
+    resolveLink: OpenGeniLinkResolver | null | undefined;
+    children: ReactNode;
+}): import("react").JSX.Element;
+/** The effective resolver from the nearest {@link OpenGeniLinkProvider}. */
+export declare function useOpenGeniLinkResolver(): OpenGeniLinkResolver | null;
+type SessionLinkClient = Partial<Pick<OpenGeniClient, "createFileDownloadUrl" | "fsRead">>;
+/**
+ * Default resolver for a session conversation that talks to Opengeni through
+ * the normal SDK client (for example behind `createSessionProxyHandler`):
+ *
+ * - `artifact:<file>` downloads the retained file through a short-lived URL.
+ * - `sandbox:<path>` downloads when enabled by the host proxy capability.
+ *
+ * Editable artifacts and Sites have no default: they need a host surface
+ * (see `@opengeni/react/artifacts/*` and `@opengeni/react/sites`), so they stay
+ * unavailable until the host resolves them.
+ */
+export declare function sessionLinkResolver(input: {
+    client: SessionLinkClient;
+    workspaceId: string;
+    sessionId: string;
+    sandboxFiles?: boolean;
+}): OpenGeniLinkResolver;
+/** An editable artifact or Site to open in a host-mounted viewer. */
+export type OpenGeniViewerTarget = Readonly<{
+    kind: "editable-artifact" | "site";
+    artifactId: string;
+    /** The link text the agent wrote, until the viewer loads the real title. */
+    title?: string | undefined;
+}>;
+/**
+ * "Open in host viewer": resolve agent links to editable artifacts and Sites
+ * in this workspace to `open(target)`, for example to mount
+ * `SessionArtifactViewer` beside the conversation. Other targets fall through.
+ */
+export declare function viewerLinkResolver(input: {
+    workspaceId: string;
+    open: (target: OpenGeniViewerTarget) => void;
+}): OpenGeniLinkResolver;

package/dist/components/openrouter-mark.d.ts

@@ -0,0 +1,6 @@
+import type { SVGProps } from "react";
+/**
+ * Simple Icons, CC0; https://github.com/simple-icons/simple-icons
+ * Source: https://raw.githubusercontent.com/simple-icons/simple-icons/develop/icons/openrouter.svg
+ */
+export declare function OpenRouterMark(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;

package/dist/components/opper-mark.d.ts

@@ -0,0 +1,7 @@
+import type { SVGProps } from "react";
+/**
+ * Opper's mark (the leaf-and-star symbol of the opper.ai wordmark), redrawn
+ * as a single currentColor path on a square box.
+ * Source: https://opper.ai (header logo SVG).
+ */
+export declare function OpperMark(props: SVGProps<SVGSVGElement>): import("react").JSX.Element;

package/dist/components/preview-loading.d.ts

@@ -0,0 +1,2 @@
+/** Private loading surface: never receives or executes the unfinished fence. */
+export declare function PreviewLoading(): import("react").JSX.Element;

package/dist/components/provider-recovery-notice.d.ts

@@ -0,0 +1,16 @@
+import { type ProviderRecoveryFacts } from "../lib/provider-recovery.js";
+export type ProviderRecoveryNoticeProps = {
+    /** From `currentProviderRecovery(session, events)`; renders nothing when null. */
+    recovery: ProviderRecoveryFacts | null | undefined;
+    /** Replaces the secondary line; `null` hides it. */
+    detail?: string | null | undefined;
+    className?: string | undefined;
+};
+export declare const PROVIDER_RECOVERY_NOTICE_DETAIL = "Your message is saved. Opengeni keeps retrying automatically for a few minutes.";
+export declare const SANDBOX_WAIT_NOTICE_DETAIL = "The turn continues automatically as soon as the sandbox is ready.";
+/**
+ * One calm, live status line while the same turn waits for an automatic retry
+ * after a transient provider failure. It replaces itself on every attempt
+ * instead of adding timeline rows, and disappears once the turn runs again.
+ */
+export declare function ProviderRecoveryNotice({ recovery, detail, className, }: ProviderRecoveryNoticeProps): import("react").JSX.Element | null;

package/dist/components/queue-item-content.d.ts

@@ -0,0 +1,9 @@
+/**
+ * One presentation rule for a queued item, shared by the full queue and the
+ * compact session-chrome dock so the two cannot drift. A turn with an empty
+ * prompt and timeline annotations is valid content; an item with neither is a
+ * malformed or legacy object that gets an explicit fallback, never a blank row.
+ */
+export type QueueItemContent = "text" | "annotations" | "unavailable";
+export declare const QUEUE_ITEM_CONTENT_UNAVAILABLE = "Content unavailable";
+export declare function queueItemContent(text: string, annotationCount: number): QueueItemContent;

package/dist/components/rehype-secret-refs.d.ts

@@ -0,0 +1,23 @@
+import type { SecretTextTokenLike } from "../secrets-ui.js";
+type HastText = {
+    type: "text";
+    value: string;
+    position?: unknown;
+};
+type HastElement = {
+    type: "element";
+    tagName: string;
+    properties?: Record<string, unknown>;
+    children: HastChild[];
+};
+type HastChild = HastText | HastElement | {
+    type: string;
+    children?: HastChild[];
+};
+type HastParent = {
+    children?: HastChild[];
+};
+export declare function rehypeSecretRefs(options: {
+    tokenize: (text: string) => SecretTextTokenLike[];
+}): (tree: HastParent) => void;
+export {};