@opengeni/react 6.8.0 → 6.9.1-canary.41937124785001

package/src/app/lib/subscription-accounts.tsx

@@ -0,0 +1,283 @@
+// One provider-neutral view of a subscription account's plan and usage for
+// every surface that lists one (Claude, ChatGPT/Codex, SuperGrok and any
+// later provider): the account menu, the model settings rows and the account
+// pages. Each provider has one adapter below that names its plans and labels
+// the usage windows it reports; everything else is shared.
+//
+// Windows come only from what the provider reported for that account. Nothing
+// here adds a window a plan doesn't have: a verified Claude Ultra account or a
+// ChatGPT Pro account reports no 5-hour window, so none is shown.
+
+/** One usage window as a data source reports it. */
+export type SubscriptionWindowInput = {
+  id: string;
+  /** Share used, 0-100; null when unknown. Over 100 can mean extra usage. */
+  usedPercent: number | null;
+  /** When the window resets: an ISO string or epoch milliseconds. */
+  resetsAt: string | number | null;
+  /**
+   * The provider's own state for the window: `exhausted` (it refused on this
+   * limit, whatever the percentage says) or `warning` (it says it is close).
+   */
+  status?: "ok" | "warning" | "exhausted" | "unknown" | null | undefined;
+};
+
+/** One usage window, ready to show. */
+export type SubscriptionWindow = {
+  id: string;
+  /** Short label: "5h", "Week", "Fable week", "Extra usage", "Credits". */
+  label: string;
+  /** Share left, 0-100; null when unknown or when the reading predates a reset. */
+  leftPercent: number | null;
+  /** The next reset, epoch milliseconds; null when unknown or already past. */
+  resetsAt: number | null;
+  limitReached: boolean;
+  /** Under 10% left, or the provider says it is close. */
+  nearLimit: boolean;
+  /** The reading was taken before this window reset, so it no longer says what is left. */
+  resetPassed: boolean;
+  /** Paid extra usage, not part of the plan's included allowance. */
+  extra: boolean;
+  /**
+   * Limits only some models (a weekly Fable, Opus or Sonnet limit): reaching
+   * it never makes the whole account read as limited.
+   */
+  scoped: boolean;
+};
+
+/** Whether the account can take work, from its windows and any refusal. */
+export type SubscriptionLimit = {
+  reached: boolean;
+  /** When the reached limit ends, epoch milliseconds, when known. */
+  until: number | null;
+  /** Not reached, but an included-usage window is near its limit. */
+  near: boolean;
+};
+
+type WindowSpec = { label: string; order: number; extra?: boolean; scoped?: boolean };
+
+type SubscriptionAdapter = {
+  /** The name plans are sold under: "Claude", "ChatGPT", "SuperGrok". */
+  planBrand: string;
+  /** The plan's own name without the brand ("Ultra", "Plus"), or null when unknown. */
+  planName(plan: string): string | null;
+  windows: Record<string, WindowSpec>;
+};
+
+/** "claude_team" → "Team", "k12" → "K12": a provider id read as words. */
+function words(id: string): string {
+  const text = id.replace(/[_-]+/g, " ").trim();
+  return text ? text.charAt(0).toLocaleUpperCase() + text.slice(1) : text;
+}
+
+const SHARED_WINDOWS: Record<string, WindowSpec> = {
+  five_hour: { label: "5h", order: 10 },
+  seven_day: { label: "Week", order: 20 },
+  overage: { label: "Extra usage", order: 90, extra: true },
+  billing: { label: "Credits", order: 30 },
+};
+
+// Anthropic sells Pro, Max and Ultra (Max 20x was renamed Ultra on 30 Oct
+// 2026). The profile reports both Max tiers as `claude_max`; the stored plan
+// carries the tier as `claude_max_5x` or `claude_max_20x` once it is known.
+const CLAUDE_PLANS: Record<string, string> = {
+  claude_free: "Free",
+  claude_pro: "Pro",
+  claude_max: "Max or Ultra",
+  claude_max_5x: "Max",
+  claude_max_20x: "Ultra",
+  claude_ultra: "Ultra",
+  claude_team: "Team",
+  claude_enterprise: "Enterprise",
+};
+
+// ChatGPT renamed Team to Business; the id stays `team`.
+const CHATGPT_PLANS: Record<string, string> = {
+  free: "Free",
+  go: "Go",
+  plus: "Plus",
+  pro: "Pro",
+  team: "Business",
+  business: "Business",
+  enterprise: "Enterprise",
+  edu: "Edu",
+};
+
+const ADAPTERS: Record<string, SubscriptionAdapter> = {
+  claude: {
+    planBrand: "Claude",
+    planName: (plan) => CLAUDE_PLANS[plan] ?? words(plan.replace(/^claude_/, "")),
+    windows: {
+      ...SHARED_WINDOWS,
+      seven_day_fable: { label: "Fable week", order: 21, scoped: true },
+      seven_day_opus: { label: "Opus week", order: 22, scoped: true },
+      seven_day_sonnet: { label: "Sonnet week", order: 23, scoped: true },
+      seven_day_overage_included: { label: "Included extra", order: 80, extra: true },
+    },
+  },
+  codex: {
+    planBrand: "ChatGPT",
+    planName: (plan) => CHATGPT_PLANS[plan.toLowerCase()] ?? words(plan),
+    // The shared core stores the 5-hour window as `primary` and the weekly
+    // one as `secondary`; both are identified by duration, never position.
+    windows: {
+      ...SHARED_WINDOWS,
+      primary: { label: "5h", order: 10 },
+      secondary: { label: "Week", order: 20 },
+    },
+  },
+  xai: {
+    planBrand: "SuperGrok",
+    // The tier may already carry the product name ("SuperGrok Heavy").
+    planName: (plan) => {
+      const tier = plan.replace(/^super\s*grok[\s_-]*/i, "").trim();
+      return tier ? words(tier) : "";
+    },
+    windows: SHARED_WINDOWS,
+  },
+};
+
+/** Any later provider: its own plan id as words and the shared window names. */
+const GENERIC_ADAPTER: SubscriptionAdapter = {
+  planBrand: "",
+  planName: (plan) => words(plan),
+  windows: SHARED_WINDOWS,
+};
+
+function adapter(provider: string): SubscriptionAdapter {
+  return ADAPTERS[provider === "supergrok" ? "xai" : provider] ?? GENERIC_ADAPTER;
+}
+
+/**
+ * The plan as the provider names it today: "Claude Ultra", "ChatGPT Plus",
+ * "SuperGrok Heavy". With `brand: false` only the plan's own name ("Ultra").
+ * Null when the plan isn't known.
+ */
+export function subscriptionPlanLabel(
+  provider: string,
+  plan: string | null | undefined,
+  options: { brand?: boolean } = {},
+): string | null {
+  const id = plan?.trim();
+  if (!id) return null;
+  const { planBrand, planName } = adapter(provider);
+  const name = planName(id);
+  if (options.brand === false) return name || planBrand || null;
+  return [planBrand, name].filter(Boolean).join(" ") || null;
+}
+
+/** A window's short label: "5h", "Week", "Fable week"; an unknown id reads as words. */
+export function subscriptionWindowLabel(provider: string, id: string): string {
+  const spec = adapter(provider).windows[id];
+  if (spec) return spec.label;
+  // A new scoped weekly limit ("seven_day_haiku") reads as "Haiku week".
+  const scoped = /^seven_day_(.+)$/.exec(id);
+  return scoped ? `${words(scoped[1]!)} week` : words(id);
+}
+
+function epoch(value: string | number | null | undefined): number | null {
+  if (value === null || value === undefined) return null;
+  const time = typeof value === "number" ? value : Date.parse(value);
+  return Number.isFinite(time) ? time : null;
+}
+
+/**
+ * Every reported window, labelled and in a stable order (5h, week, scoped
+ * weeks, credits, extra usage). A window whose reset has passed since it was
+ * read keeps its place but no longer claims a share left.
+ */
+export function subscriptionWindows(
+  provider: string,
+  inputs: readonly SubscriptionWindowInput[],
+  now: number = Date.now(),
+): SubscriptionWindow[] {
+  const specs = adapter(provider).windows;
+  return inputs
+    .map((input, index) => {
+      const reset = epoch(input.resetsAt);
+      const resetPassed = reset !== null && reset <= now;
+      const used =
+        input.usedPercent !== null && Number.isFinite(input.usedPercent) ? input.usedPercent : null;
+      const leftPercent =
+        resetPassed || used === null ? null : Math.min(100, Math.max(0, 100 - used));
+      const limitReached = !resetPassed && (input.status === "exhausted" || (used ?? 0) >= 100);
+      return {
+        index,
+        order: specs[input.id]?.order ?? 50,
+        window: {
+          id: input.id,
+          label: subscriptionWindowLabel(provider, input.id),
+          leftPercent,
+          resetsAt: resetPassed ? null : reset,
+          limitReached,
+          nearLimit:
+            !limitReached &&
+            !resetPassed &&
+            (input.status === "warning" ||
+              (leftPercent !== null && leftPercent < SUBSCRIPTION_NEAR_LIMIT_LEFT)),
+          resetPassed,
+          extra: specs[input.id]?.extra === true,
+          // A scoped weekly limit this build doesn't know ("seven_day_haiku") too.
+          scoped:
+            specs[input.id]?.scoped === true ||
+            (!specs[input.id] && /^seven_day_.+$/.test(input.id)),
+        },
+      };
+    })
+    .sort((left, right) => left.order - right.order || left.index - right.index)
+    .map((entry) => entry.window);
+}
+
+/** Below this share left, an included-usage window counts as near its limit. */
+export const SUBSCRIPTION_NEAR_LIMIT_LEFT = 10;
+
+/**
+ * The account's limit state from its included-usage windows and a stored
+ * refusal deadline. Extra usage never makes an account look limited or free,
+ * and a spent model-scoped week (Fable) only limits those models: the
+ * window says so itself, and it still counts as near a limit.
+ */
+export function subscriptionLimit(
+  windows: readonly SubscriptionWindow[],
+  exhaustedUntil: string | number | null = null,
+  now: number = Date.now(),
+): SubscriptionLimit {
+  const included = windows.filter((window) => !window.extra);
+  const reached = included.filter((window) => window.limitReached && !window.scoped);
+  const refusalEnd = epoch(exhaustedUntil);
+  const refused = refusalEnd !== null && refusalEnd > now;
+  const ends = [...reached.map((window) => window.resetsAt), ...(refused ? [refusalEnd] : [])];
+  return {
+    reached: reached.length > 0 || refused,
+    // The account serves again only once every reached limit has ended.
+    until: ends.length > 0 && ends.every((end) => end !== null) ? Math.max(...ends) : null,
+    near:
+      reached.length === 0 &&
+      !refused &&
+      included.some((window) => window.nearLimit || (window.scoped && window.limitReached)),
+  };
+}
+
+/** A Codex account's endpoint readings (five-hour and weekly, each when reported) as inputs. */
+export function codexWindowInputs(usage: {
+  fiveHour?: CodexWindowReading | null | undefined;
+  weekly?: CodexWindowReading | null | undefined;
+}): SubscriptionWindowInput[] {
+  const input = (id: string, reading: CodexWindowReading | null | undefined) => {
+    if (!reading) return [];
+    const usedPercent =
+      typeof reading.percent === "number"
+        ? reading.percent
+        : typeof reading.remaining === "number"
+          ? 100 - reading.remaining
+          : null;
+    return [{ id, usedPercent, resetsAt: reading.resetAt ?? null }];
+  };
+  return [...input("five_hour", usage.fiveHour), ...input("seven_day", usage.weekly)];
+}
+
+type CodexWindowReading = {
+  percent?: number | null | undefined;
+  remaining?: number | null | undefined;
+  resetAt?: string | null | undefined;
+};

package/src/app/routes/session.tsx

@@ -4,6 +4,7 @@ import {
   createSessionRetainedScreenshotLoader,
   createWorkspaceRetainedArtifactLoader,
   createWorkspaceRetainedVideoLoader,
+  timelineLivePause,
 } from "../../timeline";
 import { isModelUnavailableSubmissionError, type CreditRefusalKind } from "../../lib/format";
 import { inertProps } from "../../lib/inert";
@@ -4253,6 +4254,7 @@ function SessionChatPane(props: {
                           focusSequence={momentSequence}
                           events={props.events}
                           status={props.session.status}
+                          pause={timelineLivePause(admissionControl)}
                           computeLabel={computeLabel}
                           renderMessageText={renderMessageText}
                           renderMessageActions={renderMessageActions}

package/src/components/message-timeline.tsx

@@ -25,6 +25,7 @@ import {
   type TimelineSearchTarget,
 } from "./timeline-search";
 import { GenieLoadingOptionsContext, type GenieLoadingOptions } from "../timeline/genie-loading";
+import { useTimelinePauses } from "../timeline/use-timeline-pauses";
 import { ChildSessionLink } from "./child-session-link";
 import { useStartupDetails } from "../timeline/startup-preference";
 import {
@@ -133,6 +134,7 @@ import {
   defaultToolRegistry,
   groupTimeline,
   LightboxProvider,
+  type TimelineLivePause,
   type ActivityItem,
   type AgentMessageItem,
   type AuthNeededItem,
@@ -235,6 +237,14 @@ export type MessageTimelineProps = {
   items?: TimelineItem[] | undefined;
   /** Current session status (reserved; tip "Working…" chrome removed for now). */
   status?: SessionStatus | null | undefined;
+  /**
+   * The session's live Pause, from its effective control
+   * (`timelineLivePause(session.effectiveControl)`). A turn still open under a
+   * pause reads "Paused" with its clock stopped, and paused time is not
+   * counted as work. Omit to rely on the session's events alone, which do not
+   * show a pause of an ancestor or the workspace that interrupted nothing.
+   */
+  pause?: TimelineLivePause | null | undefined;
   /** Host-owned controls beside Copy and the timestamp on settled message rows. */
   renderMessageActions?: ((item: AgentMessageItem | UserMessageItem) => ReactNode) | undefined;
   /**
@@ -651,6 +661,7 @@ export function MessageTimeline({
   events,
   items,
   status: _status,
+  pause,
   renderMessageActions,
   renderMessageSender,
   renderMessageText,
@@ -820,9 +831,10 @@ export function MessageTimeline({
   const olderPageBudgetRef = useRef(0);
   const [olderDemand, setOlderDemand] = useState(0);
   const readableTurns = turnSummary?.rolling === true;
+  const pauses = useTimelinePauses(events, pause, readableTurns);
   const projectedGroups = useMemo(
-    () => groupTimeline(t, resolvedItems, { readableTurns }),
-    [resolvedItems, readableTurns, t],
+    () => groupTimeline(t, resolvedItems, { readableTurns, pauses }),
+    [resolvedItems, readableTurns, pauses, t],
   );
   // A new timeline revision (including session/turn replacement) owns layout.
   // Never leave an old decorative transform running on its retained rows.

package/src/components/session-conversation.tsx

@@ -61,7 +61,7 @@ import {
 } from "./conversation-capability-connect";
 import type { SessionMcpCapabilityCardProps } from "./session-mcp-capability-card";
 import type { SessionIntegrationCapabilityCardProps } from "./session-integration-capability-card";
-import type { AuthNeededItem } from "../timeline";
+import { timelineLivePause, type AuthNeededItem } from "../timeline";
 import { ProviderRecoveryNotice } from "./provider-recovery-notice";
 import { currentProviderRecovery } from "../lib/provider-recovery";
 import {
@@ -718,6 +718,7 @@ function ConversationView({
               emptyState={timelineProps?.emptyState}
               renderMessageSender={timelineProps?.renderMessageSender}
               status={status}
+              pause={timelineLivePause(voiceControl)}
               hasOlder={feed.hasOlder}
               loadingOlder={feed.loadingOlder}
               onLoadOlder={feed.loadOlder}

package/src/components/timeline-annotations.tsx

@@ -74,8 +74,11 @@ export function TimelineAnnotationCards({
       data-og-annotation-cards=""
       className={cn(
         "grid gap-2",
+        // Inside the timeline, let the wheel chain to the timeline once this
+        // stack is at its edge. Containing overscroll here made the whole
+        // message a dead zone for scrolling, even when the stack fit.
         annotations.length >= ANNOTATION_CARD_STACK_SCROLL_AT &&
-          "max-h-[min(28rem,55vh)] overflow-x-hidden overflow-y-auto overscroll-contain pr-1",
+          "max-h-[min(28rem,55vh)] overflow-x-hidden overflow-y-auto pr-1",
         className,
       )}
     >

package/src/components/timeline-settlement.ts

@@ -14,7 +14,7 @@ export function captureTimelineSettlement(
   if (timelineHasReader(scroller)) return null;
   const live = Array.from(
     scroller.querySelectorAll(
-      '[data-og-exchange-status="working"], [data-og-exchange-status="waiting"]',
+      '[data-og-exchange-status="working"], [data-og-exchange-status="waiting"], [data-og-exchange-status="paused"]',
     ),
   );
   // At the live tip the newest retained answer owns the transition. An older

package/src/hooks/use-composer.ts

@@ -1563,7 +1563,17 @@ export function useComposer(
     return release;
   }, []);
 
-  /** Save the draft now. The caller holds the draft slot. */
+  /**
+   * Save the draft now. The caller holds the draft slot.
+   *
+   * A save refused as made against an old revision re-reads the draft before
+   * it counts as a conflict. The same content, or content this page wrote itself (a save
+   * whose reply was lost, or one that landed after the composer remounted),
+   * is not another tab: the save just moves to the current revision. An
+   * explicit choice (Send, Keep mine) saves the person's content over
+   * whatever is there. Only an autosave that meets someone else's edit
+   * stops and offers Keep mine / Use other draft.
+   */
   const saveDraftInSlot = useCallback(
     async (
       payload: SaveComposerDraftRequest,
@@ -1571,28 +1581,62 @@ export function useComposer(
       // Receives this call's own failure (never a later autosave's), so a send
       // blocked by it keeps its real cause.
       onFailure?: (problem: Error) => void,
+      intent: "autosave" | "explicit" = "autosave",
     ): Promise<boolean> => {
       const owned = () =>
         targetKeyRef.current === owner.targetKey && targetGeneration.current === owner.generation;
       if (!sessionId || !durableDrafts || !owned()) return false;
       const current = draftRef.current;
       if (!current) return false;
-      const request = { ...payload, expectedRevision: current.revision };
+      let request = { ...payload, expectedRevision: current.revision };
       if (draftSignature(request) === lastSavedSignature.current) return true;
-      setDraftSaving(true);
-      try {
-        const saved = await client.saveComposerDraft(workspaceId, sessionId, request);
-        if (!owned()) return false;
-        adoptDraftBase(saved);
-        return true;
-      } catch (cause) {
+      const writesKey = `${workspaceId}\u0000${sessionId}`;
+      const fail = (problem: Error): false => {
         if (owned()) {
-          const problem = asError(cause);
+          // The conflict choice says what happened; a generic "conflicts with
+          // the current state" line under it would only repeat it vaguely.
           if (isDraftConflictError(problem)) setDraftConflict(problem);
-          setError(problem);
+          else setError(problem);
           onFailure?.(problem);
         }
         return false;
+      };
+      setDraftSaving(true);
+      try {
+        for (let reread = 0; ; reread += 1) {
+          let problem: Error;
+          try {
+            rememberDraftWrite(writesKey, draftContentKey(request));
+            const saved = await client.saveComposerDraft(workspaceId, sessionId, request);
+            if (!owned()) return false;
+            adoptDraftBase(saved);
+            return true;
+          } catch (cause) {
+            problem = asError(cause);
+          }
+          if (!owned()) return false;
+          if (!isDraftConflictError(problem) || reread >= DRAFT_CONFLICT_REREADS) {
+            return fail(problem);
+          }
+          let remote: ComposerDraft;
+          try {
+            remote = await client.getComposerDraft(workspaceId, sessionId);
+          } catch (cause) {
+            return fail(asError(cause));
+          }
+          if (!owned()) return false;
+          const remoteContent = draftContentKey(draftPayload(remote));
+          if (remoteContent === draftContentKey(request)) {
+            adoptDraftBase(remote);
+            return true;
+          }
+          if (intent !== "explicit" && !recentDraftWrites.get(writesKey)?.includes(remoteContent)) {
+            return fail(problem);
+          }
+          draftRef.current = remote;
+          setDraft(remote);
+          request = { ...request, expectedRevision: remote.revision };
+        }
       } finally {
         if (owned()) setDraftSaving(false);
       }
@@ -1604,6 +1648,7 @@ export function useComposer(
     async (
       payload: SaveComposerDraftRequest,
       onFailure?: (problem: Error) => void,
+      intent: "autosave" | "explicit" = "autosave",
     ): Promise<boolean> => {
       const owner = { targetKey, generation: targetGeneration.current };
       if (!sessionId || !durableDrafts || targetKeyRef.current !== owner.targetKey) {
@@ -1611,7 +1656,7 @@ export function useComposer(
       }
       const release = await acquireDraftSlot();
       try {
-        return await saveDraftInSlot(payload, owner, onFailure);
+        return await saveDraftInSlot(payload, owner, onFailure, intent);
       } finally {
         release();
       }
@@ -1869,6 +1914,7 @@ export function useComposer(
               (problem) => {
                 persistFailure = problem;
               },
+              "explicit",
             ))
           ) {
             // An update that blocks the draft save holds the send like any
@@ -2432,10 +2478,12 @@ export function useComposer(
         if (payload) {
           releaseDraftSlot = await acquireDraftSlot();
           if (
-            !(await saveDraftInSlot(payload, {
-              targetKey: ownedTargetKey,
-              generation: ownedGeneration,
-            }))
+            !(await saveDraftInSlot(
+              payload,
+              { targetKey: ownedTargetKey, generation: ownedGeneration },
+              undefined,
+              "explicit",
+            ))
           ) {
             return false;
           }
@@ -3199,7 +3247,13 @@ export function useComposer(
       setDraftConflict(null);
       setError(null);
       const payload = currentDraftPayload();
-      if (payload) await persistPayload({ ...payload, expectedRevision: remote.revision });
+      if (payload) {
+        await persistPayload(
+          { ...payload, expectedRevision: remote.revision },
+          undefined,
+          "explicit",
+        );
+      }
     },
     [
       applyDraft,
@@ -3534,19 +3588,44 @@ function draftSignature(payload: SaveComposerDraftRequest): string {
   return JSON.stringify(content);
 }
 
+/** Re-reads a save makes after "draft changed" before giving up on it. */
+const DRAFT_CONFLICT_REREADS = 3;
+
+/**
+ * The draft content this page recently wrote, per chat. It outlives a
+ * composer remount, so a save that lands after the composer re-read the
+ * draft is still recognised as this page's own write.
+ */
+const recentDraftWrites = new Map<string, string[]>();
+
+function rememberDraftWrite(chatKey: string, content: string): void {
+  const writes = (recentDraftWrites.get(chatKey) ?? []).filter((entry) => entry !== content);
+  writes.push(content);
+  recentDraftWrites.set(chatKey, writes.slice(-8));
+}
+
+/** Draft content as the server stores it, for comparing a save with a read. */
+function draftContentKey(payload: SaveComposerDraftRequest): string {
+  const { expectedRevision: _revision, resources, ...content } = payload;
+  return JSON.stringify({ ...content, resources: resources.map(resourceIdentity) });
+}
+
+function resourceIdentity(resource: ResourceRef): string {
+  // Reconnect reconciliation can restore the canonical server form while
+  // the still-mounted upload card supplies the same ready file without its
+  // default mount. Treat those two wire shapes as one selected attachment.
+  return resource.kind === "file"
+    ? `file:${resource.fileId}\u0000${resource.mountPath ?? `${DEFAULT_FILE_RESOURCE_MOUNT_ROOT}/${resource.fileId}`}`
+    : JSON.stringify(resource);
+}
+
 function mergeResources(base: ResourceRef[], additions: ResourceRef[]): ResourceRef[] {
   const seen = new Set<string>();
   return [...base, ...additions].filter((resource) => {
-    // Reconnect reconciliation can restore the canonical server form while
-    // the still-mounted upload card supplies the same ready file without its
-    // default mount. Treat those two wire shapes as one selected attachment;
-    // preserving the first representation keeps custom mounts and ordering
+    // Preserving the first representation keeps custom mounts and ordering
     // intact while preventing the draft and command paths from seeing
     // different duplicate counts after server normalization.
-    const key =
-      resource.kind === "file"
-        ? `file:${resource.fileId}\u0000${resource.mountPath ?? `${DEFAULT_FILE_RESOURCE_MOUNT_ROOT}/${resource.fileId}`}`
-        : JSON.stringify(resource);
+    const key = resourceIdentity(resource);
     if (seen.has(key)) return false;
     seen.add(key);
     return true;

package/src/hooks/use-recordings.ts

@@ -9,6 +9,7 @@ import type {
   RecordingPerson,
   RecordingVoiceprintConsent,
   RecordingSpeaker,
+  RecordingCalendarEventRef,
   RecordingTranscriptionRequest,
   RecordingTranscriptPage,
   RecordingTranscriptSegment,
@@ -172,6 +173,8 @@ export type UseRecorderOptions = RecordingsClientOverride & {
   /** Your own id for what this recording belongs to, to find it again with `useRecordings`. */
   externalRef?: string;
   metadata?: Record<string, unknown>;
+  /** The owner's calendar event the meeting is of, such as one they joined; it names the meeting. */
+  calendarEvent?: RecordingCalendarEventRef;
   transcription?: RecordingTranscriptionRequest;
   /**
    * The person recording's name, as your app knows it: their microphone's
@@ -241,6 +244,7 @@ export type UseRecorderResult = RecorderSnapshot & {
       | "transcription"
       | "externalRef"
       | "metadata"
+      | "calendarEvent"
       | "ownerName"
     >,
   ) => Promise<void>;
@@ -473,6 +477,7 @@ export function useRecorder(options: UseRecorderOptions = {}): UseRecorderResult
         ...(merged.visibility ? { visibility: merged.visibility } : {}),
         ...(merged.externalRef ? { externalRef: merged.externalRef } : {}),
         ...(merged.metadata ? { metadata: merged.metadata as never } : {}),
+        ...(merged.calendarEvent ? { calendarEvent: merged.calendarEvent } : {}),
         ...(merged.transcription ? { transcription: merged.transcription } : {}),
         ...(merged.ownerName?.trim() ? { ownerName: merged.ownerName } : {}),
         ...(merged.microphone !== undefined ? { microphone: merged.microphone } : {}),

package/src/index.ts

@@ -481,10 +481,15 @@ export {
   extractSessionRef,
   groupTimeline,
   sessionStatusFromEvents,
+  timelineLivePause,
+  timelinePauseSpans,
   toolDisplayName,
+  useTimelinePauses,
 } from "./timeline";
 export type {
   GroupTimelineOptions,
+  TimelineLivePause,
+  TimelinePauseSpan,
   ActivityItem,
   AgentMessageItem,
   AuthNeededItem,

package/src/meetings/meeting-detail-page.tsx

@@ -649,7 +649,9 @@ function FailedTranscriptActions({
     about?.funding !== "deployment"
       ? fixes.onConnectModels
       : undefined;
-  const billing = !switchTo && transcriptNeedsCredits(code) ? fixes.onOpenBilling : undefined;
+  const upgrade = code === "subscription_plan_required";
+  const billing =
+    !switchTo && (transcriptNeedsCredits(code) || upgrade) ? fixes.onOpenBilling : undefined;
   return (
     <span className="flex flex-wrap gap-2">
       {switchTo ? (
@@ -675,7 +677,7 @@ function FailedTranscriptActions({
       ) : billing ? (
         <Button type="button" size="sm" onClick={billing}>
           <CreditCardIcon aria-hidden="true" />
-          {msg("meetings.detailPage.addCredits")}
+          {msg(upgrade ? "meetings.detailPage.upgradeToPro" : "meetings.detailPage.addCredits")}
         </Button>
       ) : connect ? (
         <Button type="button" size="sm" onClick={connect}>