@opengeni/react 3.3.2 → 3.4.0

package/src/session-list-model.ts

@@ -0,0 +1,434 @@
+// Pure session-list presentation shared by the web app (rail and recent
+// sessions) and native renderers: relative-time labels, recency bucketing
+// (Today / Yesterday / Previous 7 days / Older), the running-first ordering
+// rule, status tones and the compact row metadata. No DOM, no React.
+import {
+  deriveAutomaticSessionTitlePreview,
+  deriveSessionDisplayTitle,
+  sessionTitleIsPending,
+  type ClientModel,
+  type Session,
+  type SessionListEntry,
+  type SessionStatus,
+} from "@opengeni/sdk";
+import { modelDisplayName } from "@opengeni/sdk/model-display";
+import { findPickerRow, type PickerModelRow } from "./model-policy";
+import { sessionDisplayStatus, type SessionDisplayStatus } from "./session-status-model";
+
+/** A list row may be a compact page entry or a complete session response. */
+export type SessionListRow = Session | SessionListEntry;
+
+/**
+ * The title shown for a session: durable agent/user metadata once available,
+ * otherwise a bounded opening-prompt preview while automatic naming is still
+ * pending. Every list, header and row reads identically.
+ */
+export function sessionDisplayTitle(session: SessionListRow): string {
+  return "displayTitle" in session ? session.displayTitle : deriveSessionDisplayTitle(session);
+}
+
+/** The maximum length a session title may be renamed to. */
+export const SESSION_TITLE_MAX_LENGTH = 200;
+
+/**
+ * The value a rename editor seeds from. A safe provisional prompt preview is
+ * editable because it is also what the user sees; the UUID-derived reference
+ * remains an empty draft rather than becoming an accidental rename.
+ */
+export function sessionRenameSeed(session: SessionListRow): string {
+  if ("renameSeed" in session) return session.renameSeed;
+  if (!sessionTitleIsPending(session)) {
+    return session.title?.trim() || "";
+  }
+  return deriveAutomaticSessionTitlePreview(session.initialMessage) ?? "";
+}
+
+/**
+ * Resolve a submitted draft against the current display title. Returns the
+ * trimmed title to persist, or `null` when the edit is a no-op (empty,
+ * unchanged from what is already shown, or still equal to the value that
+ * seeded this edit) and should simply cancel.
+ */
+export function resolveRenameSubmission(
+  draft: string,
+  display: string,
+  editSeed?: string,
+): string | null {
+  const next = draft.trim();
+  if (!next || next === display || (editSeed !== undefined && next === editSeed.trim())) {
+    return null;
+  }
+  return next;
+}
+
+export type SessionRecencyGroup = "today" | "yesterday" | "previous7" | "older";
+
+export const SESSION_GROUP_LABELS: Record<SessionRecencyGroup, string> = {
+  today: "Today",
+  yesterday: "Yesterday",
+  previous7: "Previous 7 days",
+  older: "Older",
+};
+
+/** The render order of recency groups, top → bottom. */
+export const SESSION_GROUP_ORDER: SessionRecencyGroup[] = [
+  "today",
+  "yesterday",
+  "previous7",
+  "older",
+];
+
+/** Live states that earn the pinned-to-top, breathing-dot treatment. */
+const RUNNING_STATUSES = new Set<SessionStatus>([
+  "running",
+  "queued",
+  "waiting_capacity",
+  "recovering",
+  "requires_action",
+]);
+
+export function isRunningStatus(status: SessionStatus): boolean {
+  return RUNNING_STATUSES.has(status);
+}
+
+/** An idle session waiting on its own timer, while its control is active. */
+export function sessionInputWait(
+  session: Pick<SessionListRow, "status" | "effectiveControl" | "inputWait">,
+) {
+  return session.status === "idle" && session.effectiveControl?.state === "active"
+    ? (session.inputWait ?? null)
+    : null;
+}
+
+export function hasActiveEffectiveControl(session: SessionListRow): boolean {
+  return (session.effectiveControl?.state ?? "active") === "active";
+}
+
+export function isEffectivelyRunning(session: SessionListRow): boolean {
+  // Background commands have their own chat indicator, not agent working status.
+  return (
+    hasActiveEffectiveControl(session) &&
+    (isRunningStatus(session.status) || Boolean(sessionInputWait(session)))
+  );
+}
+
+/** Most-recent activity timestamp for a session (updatedAt, then createdAt). */
+export function sessionActivityTime(session: SessionListRow): number {
+  const updated = Date.parse(session.updatedAt);
+  if (!Number.isNaN(updated)) {
+    return updated;
+  }
+  const created = Date.parse(session.createdAt);
+  return Number.isNaN(created) ? 0 : created;
+}
+
+/** Deterministic newest-first ordering for every flat or forest session list. */
+export function compareSessionActivity(left: SessionListRow, right: SessionListRow): number {
+  return sessionActivityTime(right) - sessionActivityTime(left) || right.id.localeCompare(left.id);
+}
+
+/** Deterministic personal-pin order: newest pin first, then descending id. */
+export function compareSessionPins(left: SessionListRow, right: SessionListRow): number {
+  const leftPinnedAt = Date.parse(left.pinnedAt ?? "");
+  const rightPinnedAt = Date.parse(right.pinnedAt ?? "");
+  const leftTime = Number.isNaN(leftPinnedAt) ? 0 : leftPinnedAt;
+  const rightTime = Number.isNaN(rightPinnedAt) ? 0 : rightPinnedAt;
+  return rightTime - leftTime || right.id.localeCompare(left.id);
+}
+
+/** Split explicit personal pins from ordinary rows without changing the input. */
+export function partitionPinnedSessions<T extends SessionListRow>(
+  sessions: T[],
+): {
+  pinned: T[];
+  ordinary: T[];
+} {
+  const pinned: T[] = [];
+  const ordinary: T[] = [];
+  for (const session of sessions) {
+    (session.pinned ? pinned : ordinary).push(session);
+  }
+  return { pinned: pinned.sort(compareSessionPins), ordinary };
+}
+
+/** A pin-aware list as the session page returns it: the person's pins, then ordinary rows. */
+export type PinnedSessionLists<T extends SessionListRow> = {
+  pinned: T[];
+  sessions: T[];
+};
+
+/** The personal pin fields a pin change or a newer read carries. */
+export type SessionPinProjection = Pick<Session, "id"> &
+  Partial<Pick<Session, "pinned" | "pinnedAt" | "pinVersion">>;
+
+/**
+ * Apply one session's pin state to a pin-aware list: the row moves between the
+ * pinned section (newest pin first) and the ordinary rows (newest activity
+ * first). Pin revisions are monotonic, so a projection older than the row
+ * already shown (a slow response after a newer change) leaves the lists as
+ * they are, unless it is `authoritative` (a fresh read after a failed change,
+ * which replaces an optimistic revision). A session in neither list is left out.
+ */
+export function applySessionPinToLists<T extends SessionListRow>(
+  lists: PinnedSessionLists<T>,
+  projection: SessionPinProjection,
+  options: { authoritative?: boolean } = {},
+): PinnedSessionLists<T> {
+  const current =
+    lists.pinned.find((row) => row.id === projection.id) ??
+    lists.sessions.find((row) => row.id === projection.id);
+  if (!current) return lists;
+  const pinVersion = projection.pinVersion ?? current.pinVersion ?? 0;
+  if (!options.authoritative && pinVersion < (current.pinVersion ?? 0)) return lists;
+  const pinned = Boolean(projection.pinned);
+  const next = {
+    ...current,
+    pinned,
+    pinnedAt: pinned ? (projection.pinnedAt ?? current.pinnedAt ?? null) : null,
+    pinVersion,
+  } as T;
+  const others = (rows: T[]) => rows.filter((row) => row.id !== projection.id);
+  return pinned
+    ? {
+        pinned: [...others(lists.pinned), next].sort(compareSessionPins),
+        sessions: others(lists.sessions),
+      }
+    : {
+        pinned: others(lists.pinned),
+        sessions: [...others(lists.sessions), next].sort(compareSessionActivity),
+      };
+}
+
+/**
+ * Which recency bucket a timestamp falls into, relative to `now`. "Today" and
+ * "Yesterday" are calendar-local; "Previous 7 days" is the rest of the trailing
+ * week; everything earlier is "Older".
+ */
+export function recencyGroupFor(timestampMs: number, now: Date = new Date()): SessionRecencyGroup {
+  const startOfToday = new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+  const startOfYesterday = startOfToday - 24 * 60 * 60 * 1000;
+  const startOfWeekWindow = startOfToday - 7 * 24 * 60 * 60 * 1000;
+  if (timestampMs >= startOfToday) {
+    return "today";
+  }
+  if (timestampMs >= startOfYesterday) {
+    return "yesterday";
+  }
+  if (timestampMs >= startOfWeekWindow) {
+    return "previous7";
+  }
+  return "older";
+}
+
+export type SessionRecencyBucket<T extends SessionListRow = SessionListRow> = {
+  group: SessionRecencyGroup;
+  label: string;
+  sessions: T[];
+};
+
+export type GroupedSessions<T extends SessionListRow = SessionListRow> = {
+  /** Running sessions, pinned above every recency group, most-recent first. */
+  running: T[];
+  /** Non-running sessions bucketed by recency (empty buckets dropped). */
+  grouped: SessionRecencyBucket<T>[];
+};
+
+/**
+ * Order + bucket the sessions for the rail. Running sessions are lifted into a
+ * synthetic, always-first position regardless of recency (rendered with a
+ * "running" marker); the remainder are bucketed by recency, most-recent first
+ * within each bucket. Empty groups are dropped.
+ */
+export function groupSessionsForRail<T extends SessionListRow>(
+  sessions: T[],
+  now: Date = new Date(),
+): GroupedSessions<T> {
+  const running = sessions.filter(isEffectivelyRunning).sort(compareSessionActivity);
+  const rest = sessions
+    .filter((session) => !isEffectivelyRunning(session))
+    .sort(compareSessionActivity);
+
+  const buckets = new Map<SessionRecencyGroup, T[]>();
+  for (const session of rest) {
+    const group = recencyGroupFor(sessionActivityTime(session), now);
+    const list = buckets.get(group) ?? [];
+    list.push(session);
+    buckets.set(group, list);
+  }
+
+  const grouped: SessionRecencyBucket<T>[] = [];
+  for (const group of SESSION_GROUP_ORDER) {
+    const list = buckets.get(group);
+    if (list && list.length > 0) {
+      grouped.push({
+        group,
+        label: SESSION_GROUP_LABELS[group],
+        sessions: list,
+      });
+    }
+  }
+  return { running, grouped };
+}
+
+export function relativeTimeLabel(value: string, now: Date = new Date()): string {
+  const timestamp = Date.parse(value);
+  if (Number.isNaN(timestamp)) {
+    return "";
+  }
+  const diffSeconds = Math.max(0, Math.floor((now.getTime() - timestamp) / 1000));
+  if (diffSeconds < 45) {
+    return "now";
+  }
+  const minutes = Math.floor(diffSeconds / 60);
+  if (minutes < 60) {
+    return `${minutes}m`;
+  }
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) {
+    return `${hours}h`;
+  }
+  const days = Math.floor(hours / 24);
+  if (days < 7) {
+    return `${days}d`;
+  }
+  return new Date(timestamp).toLocaleDateString(undefined, {
+    month: "short",
+    day: "numeric",
+  });
+}
+
+/** Codex subscription product ids are prefixed `codex/`. */
+export function isCodexProductModel(modelId: string): boolean {
+  return modelId.startsWith("codex/");
+}
+
+export type SessionStatusTone = "queued" | "running" | "waiting" | "idle" | "failed" | "cancelled";
+
+export const SESSION_STATUS_TONE: Record<SessionDisplayStatus, SessionStatusTone> = {
+  queued: "queued",
+  running: "running",
+  recovering: "running",
+  waiting_capacity: "waiting",
+  requires_action: "waiting",
+  blocked: "failed",
+  idle: "idle",
+  failed: "failed",
+  cancelled: "cancelled",
+};
+
+/** The status dot of a recent-session row: a background command reads as running. */
+export function recentSessionStatus(
+  session: Pick<SessionListRow, "status" | "backgroundCommandActivity" | "admissionBlock">,
+): { tone: SessionStatusTone; pulse: boolean } {
+  const hasBackgroundCommand = session.backgroundCommandActivity !== undefined;
+  return {
+    tone: hasBackgroundCommand ? "running" : SESSION_STATUS_TONE[sessionDisplayStatus(session)],
+    pulse: hasBackgroundCommand || session.status === "running",
+  };
+}
+
+/** A short `owner/repo` label from the session's first repository resource. */
+export function sessionRepoLabel(session: Pick<Session, "resources">): string | null {
+  const repo = session.resources.find((resource) => resource.kind === "repository");
+  if (!repo || repo.kind !== "repository") {
+    return null;
+  }
+  const parts = repo.uri
+    .replace(/\.git$/, "")
+    .split("/")
+    .filter(Boolean);
+  return parts.length >= 2 ? parts.slice(-2).join("/") : (parts.at(-1) ?? null);
+}
+
+export function recentSessionModelPresentation<TCatalog extends ClientModel>(
+  modelId: string,
+  catalogRows: readonly PickerModelRow<TCatalog>[],
+): {
+  label: string;
+  billingClass: PickerModelRow["billingClass"];
+  logoUrl?: string | undefined;
+} {
+  const row = findPickerRow([...catalogRows], modelId);
+  return {
+    label: row?.label ?? modelDisplayName(modelId),
+    logoUrl: row?.catalog.logoUrl,
+    billingClass:
+      row?.billingClass ??
+      (isCodexProductModel(modelId) ? "codex_subscription" : "opengeni_credits"),
+  };
+}
+
+/**
+ * The home screen's recent sessions: server pins first, then running, then
+ * recency buckets, capped. `sessions` keeps the all-visible-row contract, so
+ * its pins are removed before recombining the explicit pinned section.
+ */
+export function recentSessionsForHome<T extends SessionListRow>(
+  sessions: T[],
+  pinned: T[],
+  limit = 6,
+  now: Date = new Date(),
+): T[] {
+  // Sub-agent sessions are reached from their parent. In a workspace that runs
+  // many sub-agents they would otherwise take every slot (they run often) and
+  // push the person's own conversations out of the list.
+  const ordinary = sessions.filter((session) => !session.pinned && !session.parentSessionId);
+  const { running, grouped } = groupSessionsForRail(ordinary, now);
+  const topLevelPinned = pinned.filter((session) => !session.parentSessionId);
+  return [...topLevelPinned, ...running, ...grouped.flatMap((bucket) => bucket.sessions)].slice(
+    0,
+    limit,
+  );
+}
+
+/** One project (workspace channel) and its sessions, as the web rail groups them. */
+export type SessionProjectSection<T extends SessionListRow = SessionListRow> = {
+  /** The channel id, or "default" for unfiled sessions. */
+  key: string;
+  channelId: string | null;
+  name: string;
+  sessions: T[];
+};
+
+/**
+ * Group top-level sessions by project in the server's project order (pinned
+ * projects first), then "Default" for unfiled ones and those whose project no
+ * longer exists. Running sessions lead each project, then the most recent.
+ * Sub-agent sessions are reached from their parent, so they are left out.
+ * Projects without sessions are kept only when `keepEmpty` is set.
+ */
+export function groupSessionsByProject<T extends SessionListRow & { channelId?: string | null }>(
+  sessions: readonly T[],
+  projects: readonly { id: string; name: string }[],
+  options: { keepEmpty?: boolean } = {},
+): SessionProjectSection<T>[] {
+  const known = new Set(projects.map((project) => project.id));
+  const byProject = new Map<string | null, T[]>();
+  for (const session of sessions) {
+    if ("parentSessionId" in session && session.parentSessionId) continue;
+    const channelId = session.channelId ?? null;
+    const key = channelId !== null && known.has(channelId) ? channelId : null;
+    byProject.set(key, [...(byProject.get(key) ?? []), session]);
+  }
+  const order = (list: T[]) =>
+    [...list].sort(
+      (left, right) =>
+        Number(isEffectivelyRunning(right)) - Number(isEffectivelyRunning(left)) ||
+        compareSessionActivity(left, right),
+    );
+  const sections: SessionProjectSection<T>[] = projects
+    .map((project) => ({
+      key: project.id,
+      channelId: project.id,
+      name: project.name,
+      sessions: order(byProject.get(project.id) ?? []),
+    }))
+    .filter((section) => options.keepEmpty || section.sessions.length > 0);
+  const unfiled = byProject.get(null) ?? [];
+  if (unfiled.length > 0) {
+    sections.push({ key: "default", channelId: null, name: "Default", sessions: order(unfiled) });
+  }
+  return sections;
+}
+
+export { findPickerRow };

package/src/session-realtime.ts

@@ -0,0 +1,18 @@
+/**
+ * Platform-neutral session realtime for any React host (web or React Native):
+ * the controller hook, admission rules and the workspace voice-model catalog.
+ * Native hosts inject their WebRTC through `controllerFactory`.
+ */
+export {
+  CODEX_LIVE_MODEL,
+  codexRealtimeAdmissionAllowed,
+  codexRealtimeAdmissionBlocker,
+  sessionRealtimeLifecycleIsActive,
+  useRealtimeModelSelection,
+  useSessionRealtime,
+} from "./realtime/session-realtime";
+export type {
+  RealtimeControllerClient,
+  RealtimeModelOption,
+  SessionRealtimeControllerFactory,
+} from "./realtime/session-realtime";

package/src/session-status-model.ts

@@ -0,0 +1,99 @@
+import type { SessionStatus } from "@opengeni/sdk";
+
+/** Status token family (`--og-color-status-<tone>`) for a session status. */
+export type SessionStatusTone = "queued" | "running" | "waiting" | "idle" | "failed" | "cancelled";
+
+/**
+ * The status a person sees. `blocked` is a `requires_action` session whose
+ * next turn the runtime refused to start (an admission block): nothing is
+ * asked of the person, so it must not read as "Waiting on you". Accepted work
+ * is kept, and Resume (or a new message) rechecks and starts it again.
+ */
+export type SessionDisplayStatus = SessionStatus | "blocked";
+
+/** True when a `requires_action` session is held by an admission block, not by a person. */
+export function sessionAdmissionBlocked(session: {
+  status: SessionStatus;
+  admissionBlock?: unknown;
+}): boolean {
+  return (
+    session.status === "requires_action" &&
+    typeof session.admissionBlock === "object" &&
+    session.admissionBlock !== null
+  );
+}
+
+/** The status to present for a session (or a list row carrying its admission block). */
+export function sessionDisplayStatus(session: {
+  status: SessionStatus;
+  admissionBlock?: unknown;
+}): SessionDisplayStatus {
+  return sessionAdmissionBlocked(session) ? "blocked" : session.status;
+}
+
+/** Renderer-neutral session status presentation: label, color family and liveness. */
+export const SESSION_STATUS_PRESENTATION: Record<
+  SessionDisplayStatus,
+  { label: string; tone: SessionStatusTone; pulse: boolean }
+> = {
+  queued: { label: "Queued", tone: "queued", pulse: false },
+  running: { label: "Running", tone: "running", pulse: true },
+  recovering: { label: "Recovering", tone: "running", pulse: true },
+  // Model subscription capacity is exhausted; the turn continues by itself.
+  waiting_capacity: { label: "Limit reached", tone: "waiting", pulse: true },
+  idle: { label: "Idle", tone: "idle", pulse: false },
+  requires_action: { label: "Waiting on you", tone: "waiting", pulse: true },
+  // The runtime could not start the next turn. Nothing moves until a recheck.
+  blocked: { label: "Stuck", tone: "failed", pulse: false },
+  failed: { label: "Failed", tone: "failed", pulse: false },
+  cancelled: { label: "Cancelled", tone: "cancelled", pulse: false },
+};
+
+/**
+ * The status badge's color tokens (text, border and its alpha); the fill is the
+ * status color at 10%. Mirrors the web badge classes, for non-DOM renderers.
+ */
+export const SESSION_STATUS_BADGE: Record<
+  SessionDisplayStatus,
+  { text: string; border: string; borderAlpha: number; fill: string }
+> = {
+  queued: { text: "fg-muted", border: "border", borderAlpha: 1, fill: "status-queued" },
+  running: {
+    text: "status-running",
+    border: "status-running",
+    borderAlpha: 0.3,
+    fill: "status-running",
+  },
+  recovering: {
+    text: "status-running",
+    border: "status-running",
+    borderAlpha: 0.3,
+    fill: "status-running",
+  },
+  waiting_capacity: {
+    text: "status-waiting",
+    border: "status-waiting",
+    borderAlpha: 0.35,
+    fill: "status-waiting",
+  },
+  idle: { text: "status-idle", border: "status-idle", borderAlpha: 0.3, fill: "status-idle" },
+  requires_action: {
+    text: "status-waiting",
+    border: "status-waiting",
+    borderAlpha: 0.35,
+    fill: "status-waiting",
+  },
+  blocked: {
+    text: "status-failed",
+    border: "status-failed",
+    borderAlpha: 0.35,
+    fill: "status-failed",
+  },
+  failed: {
+    text: "status-failed",
+    border: "status-failed",
+    borderAlpha: 0.35,
+    fill: "status-failed",
+  },
+  cancelled: { text: "fg-subtle", border: "border", borderAlpha: 1, fill: "status-cancelled" },
+};

package/src/session-ui.ts

@@ -8,13 +8,55 @@ export type {
   HumanInputFormProps,
 } from "./components/human-input-form";
 export { HumanInputSurface } from "./components/human-input-surface";
+export {
+  SecretAnswerChip,
+  SecretRefChip,
+  SecretRefText,
+  secretReferenceLabel,
+} from "./components/secret-ref-chip";
+export type {
+  SecretAnswerChipProps,
+  SecretRefChipProps,
+  SecretRefTextProps,
+  SecretReferenceLabel,
+} from "./components/secret-ref-chip";
+export { SecretsUiProvider } from "./secrets-ui";
+export { ApprovalSurface } from "./components/approval-surface";
+export { ToolActionReviewCard, ToolActionReviewDetails } from "./components/tool-action-review";
+export type { ToolReviewDetailsLoader } from "./components/tool-action-review";
+export type { ApprovalSurfaceProps, ApprovalSurfaceMessages } from "./components/approval-surface";
 export type { HumanInputSurfaceProps } from "./components/human-input-surface";
 export { MessageTimeline, TimelineRow } from "./components/message-timeline";
 export type { MessageTimelineProps } from "./components/message-timeline";
+export type { RenderAllowanceExhausted } from "./timeline/allowance-exhausted-row";
+export type { AllowanceLabels, AllowanceScope } from "./usage/allowance-copy";
+export {
+  OpenGeniLinkProvider,
+  chainLinkResolvers,
+  sessionLinkResolver,
+  useOpenGeniLinkResolver,
+  viewerLinkResolver,
+} from "./components/open-geni-links";
+export type {
+  OpenGeniLinkResolution,
+  OpenGeniLinkResolver,
+  OpenGeniLinkTarget,
+  OpenGeniViewerTarget,
+} from "./components/open-geni-links";
+export { parseOpenGeniLink } from "@opengeni/sdk";
+export {
+  ArtifactLabelsProvider,
+  DEFAULT_ARTIFACT_LABELS,
+  type ArtifactLabels,
+} from "./components/artifacts/artifact-chrome";
+export type { TimelineSearchTarget } from "./components/timeline-search";
 export { createOlderHistoryLoadReceipt } from "./older-history";
 export type { OlderHistoryLoader, OlderHistoryLoadReceipt } from "./older-history";
 export { UserMessageBody, userMessageLikelyNeedsDisclosure } from "./components/user-message-body";
-export type { UserMessageBodyProps } from "./components/user-message-body";
+export type {
+  UserMessageBodyProps,
+  UserMessageDisclosureLabels,
+} from "./components/user-message-body";
 export { BUILT_IN_TURN_SUMMARY_FACET_IDS } from "./timeline/turn-summary";
 export type {
   BuiltInTurnSummaryFacetId,
@@ -25,6 +67,51 @@ export type {
   TurnSummaryOptions,
 } from "./timeline/turn-summary";
 export { QueueSurface } from "./components/queue-surface";
+// The provider too, so a host needs only this entry (the root also exports the
+// workbench, whose editors, terminal and desktop are optional peers).
+export { OpenGeniProvider } from "./provider";
+export type { OpenGeniProviderProps, ErrorMessageFormatter } from "./provider";
+// The tool-renderer registry, so custom tool renderers need no root import.
+export { createDefaultToolRegistry, createToolRegistry, defaultToolRegistry } from "./timeline";
+export type {
+  CreateToolRegistryOptions,
+  ToolRegistry,
+  ToolRegistryEntry,
+  ToolRenderer,
+  ToolRendererProps,
+} from "./timeline";
+export { SessionConversation, SessionConversationView } from "./components/session-conversation";
+export { useSessionConversation } from "./hooks/use-session-conversation";
+export { useNewConversation } from "./hooks/use-new-conversation";
+export type {
+  NewConversationController,
+  UseNewConversationOptions,
+  NewConversationCreateOptions,
+  CreatedConversation,
+} from "./hooks/use-new-conversation";
+export { NewConversation, NewConversationView } from "./components/new-conversation";
+export type {
+  NewConversationProps,
+  NewConversationViewProps,
+  NewConversationLabels,
+} from "./components/new-conversation";
+export type {
+  SessionConversationController,
+  UseSessionConversationOptions,
+} from "./hooks/use-session-conversation";
+export { SessionList } from "./components/session-list";
+export type { SessionListLabels, SessionListProps } from "./components/session-list";
+export { OpenGeniChat } from "./components/open-geni-chat";
+export type {
+  OpenGeniChatCreateOptions,
+  OpenGeniChatLabels,
+  OpenGeniChatProps,
+} from "./components/open-geni-chat";
+export type {
+  SessionConversationLabels,
+  SessionConversationProps,
+  SessionConversationViewProps,
+} from "./components/session-conversation";
 export type { QueueSurfaceProps } from "./components/queue-surface";
 export {
   SessionChrome,
@@ -38,3 +125,13 @@ export type {
   SessionChromeSignalId,
   SessionChromeSignalTone,
 } from "./components/session-chrome";
+export { SessionCommandsPanel } from "./components/session-commands-panel";
+export { SessionCommands } from "./components/session-commands";
+
+export { KnowledgeActivityProvider } from "./timeline/knowledge-receipt";
+export type { KnowledgeActivityActions } from "./timeline/knowledge-receipt";
+export { StartupTimings } from "./timeline/startup-timings";
+export { useStartupDetails, setStartupDetails } from "./timeline/startup-preference";
+export type { GenieLoadingOptions } from "./timeline/genie-loading";
+
+export { ToolReviewHistoryProvider } from "./components/tool-review-history";