@opengeni/react 4.6.1 → 4.6.2-canary.39854174564001

package/src/app/components/session/subscription-account.ts

@@ -0,0 +1,354 @@
+// One provider-neutral shape for a chat's subscription account (Codex, Claude,
+// SuperGrok) and its projection onto the account menu. Data sources normalize
+// into `SubscriptionAccountState`; everything a person sees is decided here,
+// so every provider shows the same structure and copy. Only names, marks and
+// plan labels differ.
+import type { ClientModel, ModelAccountChoiceRefusal } from "@opengeni/sdk";
+import { isCodexProductModel } from "../../lib/session-model";
+import type { BillingClass } from "../billing-class-mark";
+import type {
+  SubscriptionAccountMenuRow,
+  SubscriptionAccountMenuUsage,
+  SubscriptionAccountUsageWindow,
+} from "./subscription-account-menu";
+
+export type SubscriptionAccountUsage = {
+  /** When the reading was taken; null when unknown. */
+  observedAt: string | null;
+  windows: Array<{
+    id: string;
+    /** Null means unknown; values over 100 can represent overage. */
+    usedPercent: number | null;
+    resetsAt: string | null;
+    status: "ok" | "warning" | "exhausted" | "unknown";
+  }>;
+  exhaustedUntil: string | null;
+  exhaustedKind: "quota" | "rate_limit" | null;
+};
+
+export type SubscriptionAccount = {
+  id: string;
+  label: string | null;
+  email: string | null;
+  plan: string | null;
+  /** Who the account belongs to; null when the source does not say. */
+  source: "personal" | "workspace" | "organization" | null;
+  /** The provider's account status (`active`, `needs_relogin`, …). */
+  status: string;
+  refusal: ModelAccountChoiceRefusal | null;
+  choosable: boolean;
+  /** Undefined: not reported. Null: no reading yet. */
+  usage: SubscriptionAccountUsage | null | undefined;
+};
+
+export type SubscriptionAccountState = {
+  /** `codex`, `claude`, `xai`, … */
+  provider: string;
+  /** True until the first read settles. */
+  loading: boolean;
+  /** The accounts could not be read. */
+  unavailable: boolean;
+  /** Accounts this person can pick for the next turn. */
+  accounts: SubscriptionAccount[];
+  /** The account the chat runs on (or will next), when this person can see it. */
+  current: SubscriptionAccount | null;
+  /** The chat runs on a chosen or serving account this person cannot see. */
+  currentHidden: boolean;
+  /** `current`/`currentHidden` is the account serving the chat's latest turn. */
+  serving: boolean;
+  /** Automatic selection, not a person's explicit choice. */
+  automatic: boolean;
+  /** The explicitly chosen account, when this person can see it. */
+  chosenId: string | null;
+  /** A turn waits for capacity on the current account. */
+  waiting: boolean;
+  /**
+   * A live usage check, for sources that offer one: `checking` until its
+   * first reading arrives, `failed` when it produced none for this account.
+   */
+  usageCheck: "idle" | "checking" | "failed";
+  choosing: boolean;
+  /** The in-flight target (`null` is automatic; `undefined` when idle). */
+  choosingTarget: string | null | undefined;
+  appliedTo: "waiting_turn" | "next_turn" | null;
+  mutationError: string | null;
+};
+
+const PROVIDER: Record<string, { name: string; billingClass: BillingClass }> = {
+  codex: { name: "Codex", billingClass: "codex_subscription" },
+  claude: { name: "Claude", billingClass: "claude_subscription" },
+  xai: { name: "SuperGrok", billingClass: "supergrok_subscription" },
+};
+
+export function subscriptionProviderPresentation(provider: string): {
+  name: string;
+  billingClass: BillingClass;
+} {
+  return PROVIDER[provider] ?? { name: "Subscription", billingClass: "external" };
+}
+
+// Presentation labels only. Preserve every supplied window; never combine
+// family-specific, overage or partial windows into an account capacity score.
+const WINDOW_LABEL: Record<string, string> = {
+  // Neutral ids: they do not say how long the window is.
+  primary: "Primary",
+  secondary: "Secondary",
+  five_hour: "5h",
+  seven_day: "Week",
+  seven_day_opus: "Week · Opus",
+  seven_day_sonnet: "Week · Sonnet",
+  overage: "Overage",
+  billing: "Billing",
+};
+
+const REFUSAL_COPY: Record<ModelAccountChoiceRefusal, string> = {
+  inactive: "Unavailable",
+  personal_not_allowed: "Turned off here",
+  personal_not_owner_work: "Not available for this chat",
+  session_has_no_owner: "Needs an owner",
+};
+
+const STATUS_COPY: Record<string, string> = {
+  needs_relogin: "Needs reconnect",
+  error: "Error",
+  disabled: "Disabled",
+  revoked: "Revoked",
+  expired: "Expired",
+  suspended: "Suspended",
+  paused: "Paused",
+  inactive: "Inactive",
+  limit_reached: "Limit reached",
+};
+
+function time(value: string | null): string | null {
+  if (!value || !Number.isFinite(Date.parse(value))) return null;
+  return new Date(value).toLocaleString(undefined, {
+    month: "short",
+    day: "numeric",
+    hour: "numeric",
+    minute: "2-digit",
+  });
+}
+
+export function accountLabel(account: SubscriptionAccount): string {
+  return account.label ?? account.email ?? account.plan ?? "Account";
+}
+
+export function accountStatus(account: SubscriptionAccount): string | null {
+  // Inactive is a broad refusal; retain the actual status when it explains why.
+  if (account.refusal && account.refusal !== "inactive") return REFUSAL_COPY[account.refusal];
+  if (account.status !== "active") return STATUS_COPY[account.status] ?? account.status;
+  return account.refusal ? REFUSAL_COPY[account.refusal] : null;
+}
+
+function accountSource(account: SubscriptionAccount): string | null {
+  return account.source === "personal"
+    ? "Your account"
+    : account.source === "workspace"
+      ? "This workspace"
+      : account.source === "organization"
+        ? "Organization"
+        : null;
+}
+
+function windowLabel(id: string): string {
+  return WINDOW_LABEL[id] ?? id;
+}
+
+/** The reading as usage rows: percentage used, with when each window resets. */
+export function subscriptionAccountUsage(
+  usage: SubscriptionAccountUsage | null | undefined,
+  now = Date.now(),
+): {
+  windows?: SubscriptionAccountUsageWindow[];
+  message?: string;
+  note?: string;
+  summary?: string;
+} {
+  if (!usage) return { message: "No usage reading yet" };
+  const observed = time(usage.observedAt);
+  const windows = usage.windows.map((window) => {
+    const reset = time(window.resetsAt);
+    const past = reset !== null && Date.parse(window.resetsAt!) <= now;
+    return {
+      label: windowLabel(window.id),
+      usedPercent: window.usedPercent,
+      detail: [
+        window.status === "unknown"
+          ? "Status unknown"
+          : window.status === "warning"
+            ? "Near its limit"
+            : window.status === "exhausted"
+              ? "Limit reached"
+              : null,
+        past ? "Reset passed; usage may be outdated" : reset ? `Resets ${reset}` : null,
+      ]
+        .filter(Boolean)
+        .join(" · "),
+    };
+  });
+  const exhaustedTime = time(usage.exhaustedUntil);
+  // A limit whose end has passed no longer applies.
+  const exhausted =
+    usage.exhaustedKind !== null &&
+    !(usage.exhaustedUntil && Date.parse(usage.exhaustedUntil) <= now);
+  return {
+    windows,
+    ...(windows.length === 0
+      ? {
+          message: exhausted
+            ? `Limit reached${exhaustedTime ? ` until ${exhaustedTime}` : ""}`
+            : "No usage reading yet",
+        }
+      : {}),
+    ...(observed ? { note: `Updated ${observed}` } : {}),
+    ...(windows.length > 0
+      ? {
+          summary: `${windows
+            .map(
+              (window) =>
+                `${window.label} ${window.usedPercent === null ? "unknown" : `${Math.round(window.usedPercent)}%`}`,
+            )
+            .join(" · ")} used`,
+        }
+      : {}),
+  };
+}
+
+function nearLimit(usage: SubscriptionAccountUsage | null | undefined): boolean {
+  return (usage?.windows ?? []).some(
+    (window) =>
+      window.status === "warning" ||
+      window.status === "exhausted" ||
+      (window.usedPercent !== null && window.usedPercent >= 90),
+  );
+}
+
+/**
+ * Whether there is anything to show or choose. A chat whose provider offers
+ * no accounts to this person, with nothing chosen, serving or waiting, shows
+ * the provider's mark alone instead of an empty menu.
+ */
+export function showsSubscriptionAccountMenu(state: SubscriptionAccountState): boolean {
+  return (
+    state.unavailable ||
+    state.accounts.length > 0 ||
+    state.current !== null ||
+    state.currentHidden ||
+    state.waiting ||
+    !state.automatic
+  );
+}
+
+/**
+ * The subscription whose accounts a chat's header offers, or null for a chat
+ * that does not run on a subscription. Codex product models are Codex
+ * subscriptions even before the catalog lists them.
+ */
+export function subscriptionAccountProvider(
+  modelId: string,
+  credentialSource: ClientModel["credentialSource"],
+): string | null {
+  if (isCodexProductModel(modelId)) return "codex";
+  return credentialSource?.kind === "connected_subscription" ? credentialSource.provider : null;
+}
+
+/** Everything the account menu shows, from the neutral state. */
+export function subscriptionAccountMenuContent(state: SubscriptionAccountState) {
+  const { name } = subscriptionProviderPresentation(state.provider);
+  const current = state.current;
+  // A failed read does not know the selection; never claim Automatic for it.
+  const unknown = state.unavailable && !current && !state.currentHidden;
+  const displayName = current
+    ? accountLabel(current)
+    : state.currentHidden
+      ? "Account unavailable"
+      : unknown
+        ? "Accounts unavailable"
+        : "Automatic";
+  const status = current ? accountStatus(current) : null;
+  const selectionLabel = state.waiting
+    ? "Limit reached"
+    : state.serving && (current || state.currentHidden)
+      ? "Current account"
+      : !state.automatic && !unknown && (!current || current.id === state.chosenId)
+        ? "Chosen account"
+        : current
+          ? "Current account"
+          : "Account selection";
+  const usageNearLimit = nearLimit(current?.usage);
+  const tone: "ok" | "warn" | "bad" =
+    current?.status === "needs_relogin" || current?.status === "error"
+      ? "bad"
+      : status || state.waiting || usageNearLimit
+        ? "warn"
+        : "ok";
+  const usage: SubscriptionAccountMenuUsage = !current
+    ? {
+        message: state.currentHidden
+          ? "Account usage hidden"
+          : unknown
+            ? "Usage unavailable"
+            : "Choose an account to see usage",
+      }
+    : state.usageCheck === "checking"
+      ? { checking: true }
+      : state.usageCheck === "failed"
+        ? { unavailable: true }
+        : subscriptionAccountUsage(current.usage);
+  const accounts: SubscriptionAccountMenuRow[] = state.accounts.map((account) => ({
+    id: account.id,
+    label: accountLabel(account),
+    plan: account.plan,
+    status: accountStatus(account),
+    detail: [
+      accountLabel(account),
+      account.email,
+      account.plan,
+      accountSource(account),
+      accountStatus(account),
+    ]
+      .filter(Boolean)
+      .join(" · "),
+    personal: account.source === "personal",
+    disabled: !account.choosable,
+    // The current account's usage is already shown above the list.
+    usageSummary:
+      account.id === current?.id || state.usageCheck === "checking"
+        ? undefined
+        : subscriptionAccountUsage(account.usage).summary,
+  }));
+  return {
+    ariaLabel: [
+      `${name} account`,
+      displayName,
+      state.waiting ? "Limit reached" : (status ?? (usageNearLimit ? "Near its limit" : null)),
+    ]
+      .filter(Boolean)
+      .join(" · "),
+    selectionLabel,
+    displayName,
+    identity: current?.email && current.email !== displayName ? current.email : null,
+    metadata: current
+      ? [current.plan, accountSource(current), status].filter(Boolean).join(" · ") ||
+        `${name} subscription`
+      : `${name} subscription`,
+    tone,
+    usage,
+    accounts,
+    selectedId: state.automatic || unknown ? null : state.chosenId,
+    automaticSelected: state.automatic && !unknown,
+    actionLabel: state.waiting ? "Retry with" : "Use for next turn",
+    automaticLabel: "Automatic",
+    emptyMessage: state.unavailable ? "Accounts unavailable." : "No accounts available.",
+    error: state.mutationError ? `Couldn't switch: ${state.mutationError}` : null,
+    note:
+      state.appliedTo === "waiting_turn"
+        ? "Selection saved. Capacity is being rechecked."
+        : state.appliedTo === "next_turn"
+          ? "Selection saved for the next turn."
+          : state.waiting
+            ? "Changing accounts retries the waiting turn."
+            : "Applies next turn. The current turn keeps its account.",
+  };
+}

package/src/app/lib/actions/actions-provider.tsx

@@ -31,6 +31,7 @@ import { workspacesByOrganization } from "../org";
 import { hasWorkspacePermission } from "../permissions";
 import { readChatDirectory, recordChatVisit } from "./chat-directory";
 import {
+  extendChatSwitcher,
   isSwitcherKey,
   openChatSwitcher,
   stepChatSwitcher,
@@ -575,6 +576,16 @@ export function ActionsProvider(props: { children: ReactNode }) {
               const current = switcherRef.current;
               if (current) setSwitcher({ ...current, index });
             }}
+            onDirectoryChange={() => {
+              const current = switcherRef.current;
+              if (!current) return;
+              const next = extendChatSwitcher(
+                current,
+                readChatDirectory(subjectId, workspaceId),
+                reachableRef.current,
+              );
+              if (next !== current) setSwitcher(next);
+            }}
             onPick={pickSwitcherChat}
             onDismiss={() => setSwitcher(null)}
           />

package/src/app/lib/actions/actions.test.ts

@@ -9,7 +9,13 @@ import {
   type Chord,
 } from "./chords";
 import type { ChatRecord } from "./chat-directory";
-import { isSwitcherKey, openChatSwitcher, stepChatSwitcher, SWITCHER_LIMIT } from "./chat-switcher";
+import {
+  extendChatSwitcher,
+  isSwitcherKey,
+  openChatSwitcher,
+  stepChatSwitcher,
+  SWITCHER_LIMIT,
+} from "./chat-switcher";
 import { LOOSE_MATCH_BELOW, rankLabel, rankWithKeywords } from "./rank";
 import { appActions, stepWorkspace } from "./registry";
 
@@ -296,9 +302,58 @@ describe("chat switcher", () => {
     expect(state.ids[state.index]).toBe("b");
   });
 
-  test("the list stops at ten chats", () => {
-    const ids = Array.from({ length: 15 }, (_, index) => `c${index}`);
-    expect(openChatSwitcher(directory(ids), "c0", false)!.ids).toHaveLength(SWITCHER_LIMIT);
+  test("past the opened chats it carries on through other chats by latest activity", () => {
+    const rows = [
+      record("a", { updatedAt: 1 }),
+      record("b", { updatedAt: 2 }),
+      record("older", { updatedAt: 5 }),
+      record("newer", { updatedAt: 9, workspaceId: "other" }),
+      record("gone", { updatedAt: 8, archived: true }),
+      record("child", { updatedAt: 7, row: { parentSessionId: "a" } as ChatRecord["row"] }),
+    ];
+    const state = openChatSwitcher(directory(["a", "b"], rows), "a", false)!;
+    expect(state.ids).toEqual(["a", "b", "newer", "older"]);
+    expect(state.viewed).toBe(2);
+    // Tab keeps going into the older chats before it wraps.
+    let stepped = stepChatSwitcher(state, 1);
+    stepped = stepChatSwitcher(stepped, 1);
+    expect(stepped.ids[stepped.index]).toBe("older");
+  });
+
+  test("with no opened chats yet, the most recently active chat is the target", () => {
+    const rows = [record("a", { updatedAt: 1 }), record("b", { updatedAt: 2 })];
+    const state = openChatSwitcher(directory([], rows), null, false)!;
+    expect(state.ids).toEqual(["b", "a"]);
+    expect(state.viewed).toBe(0);
+    expect(state.ids[state.index]).toBe("b");
+  });
+
+  test("chats that load while it is open join at the end, and nothing else moves", () => {
+    const start = directory(["a", "b"], [record("a"), record("b"), record("c", { updatedAt: 3 })]);
+    const state = stepChatSwitcher(openChatSwitcher(start, "a", false)!, 1);
+    expect(extendChatSwitcher(state, start)).toBe(state);
+    const later = directory(
+      ["a", "b"],
+      [record("a"), record("b"), record("c", { updatedAt: 3 }), record("d", { updatedAt: 9 })],
+    );
+    const grown = extendChatSwitcher(state, later);
+    expect(grown.ids).toEqual(["a", "b", "c", "d"]);
+    expect(grown.index).toBe(state.index);
+    expect(grown.viewed).toBe(2);
+  });
+
+  test("the list stops at its limit", () => {
+    const ids = Array.from({ length: SWITCHER_LIMIT + 20 }, (_, index) => `c${index}`);
+    const rows = Array.from({ length: 30 }, (_, index) =>
+      record(`x${index}`, { updatedAt: index }),
+    );
+    const state = openChatSwitcher(
+      directory(ids, [...ids.map((id) => record(id)), ...rows]),
+      "c0",
+      false,
+    )!;
+    expect(state.ids).toHaveLength(SWITCHER_LIMIT);
+    expect(extendChatSwitcher(state, directory(ids, rows))).toBe(state);
   });
 
   test("only Control+Tab opens it", () => {

package/src/app/lib/actions/chat-switcher.ts

@@ -5,50 +5,103 @@
  * chat (press again to return); holding Control shows the list, each Tab moves
  * down it (Shift+Tab up), and releasing Control opens the highlighted chat.
  *
- * The list is read once when the switcher opens, so it holds still while the
- * person cycles through it.
+ * Past the chats someone opened, the list carries on through the other chats
+ * the app knows, most recently active first, so holding Tab keeps going back
+ * in time. The list is read when the switcher opens and only ever grows at
+ * the end (as more chats load), so it holds still while the person cycles.
  */
-import type { ChatDirectorySnapshot } from "./chat-directory";
+import type { ChatDirectorySnapshot, ChatRecord } from "./chat-directory";
 
 /** At most this many chats; older ones are a search away in ⌘K. */
-export const SWITCHER_LIMIT = 10;
+export const SWITCHER_LIMIT = 100;
 /** A press shorter than this switches without ever drawing the list. */
 export const SWITCHER_SHOW_DELAY_MS = 140;
 
 export type ChatSwitcherState = Readonly<{
-  /** Chats in the order shown, most recently viewed first. */
+  /** Chats in the order shown: recently viewed first, then recently active. */
   ids: readonly string[];
+  /** How many of `ids`, from the front, are chats the person opened recently. */
+  viewed: number;
   /** The highlighted chat. */
   index: number;
   /** Whether the list is drawn (after the delay, or once Tab is pressed again). */
   visible: boolean;
 }>;
 
+type SwitcherDirectory = Pick<ChatDirectorySnapshot, "recent" | "rows">;
+
+function switchable(
+  record: ChatRecord | undefined,
+  reachable: (workspaceId: string) => boolean,
+): boolean {
+  if (!record || record.archived || !reachable(record.workspaceId)) return false;
+  // Subagent chats live under their parent, as in the sidebar.
+  return !record.row || record.row.parentSessionId === null;
+}
+
+/** Known chats not in `taken`, most recently active first. */
+function moreChats(
+  directory: SwitcherDirectory,
+  taken: ReadonlySet<string>,
+  reachable: (workspaceId: string) => boolean,
+  room: number,
+): string[] {
+  if (room <= 0) return [];
+  const more: ChatRecord[] = [];
+  for (const record of directory.rows.values()) {
+    if (!taken.has(record.id) && switchable(record, reachable)) more.push(record);
+  }
+  more.sort((a, b) => b.updatedAt - a.updatedAt || (a.id < b.id ? -1 : 1));
+  return more.slice(0, room).map((record) => record.id);
+}
+
 /**
- * The chats to switch between, most recently viewed first, with the open chat
- * (when there is one) at the front. Null when there is nowhere to switch to.
+ * The chats to switch between: the open chat (when there is one), the other
+ * recently viewed chats, then the rest the app knows by latest activity.
+ * Null when there is nowhere to switch to.
  */
 export function openChatSwitcher(
-  directory: Pick<ChatDirectorySnapshot, "recent" | "rows">,
+  directory: SwitcherDirectory,
   currentChatId: string | null,
   backwards: boolean,
   /** Whether a workspace is still open to the person; chats elsewhere are left out. */
   reachable: (workspaceId: string) => boolean = () => true,
 ): ChatSwitcherState | null {
-  const switchable = directory.recent.filter((id) => {
-    const record = directory.rows.get(id);
-    if (!record || record.archived || !reachable(record.workspaceId)) return false;
-    // Subagent chats live under their parent, as in the sidebar.
-    return !record.row || record.row.parentSessionId === null;
-  });
-  const ids = currentChatId
-    ? [currentChatId, ...switchable.filter((id) => id !== currentChatId)]
-    : switchable;
-  const limited = ids.slice(0, SWITCHER_LIMIT);
+  const recent = directory.recent.filter(
+    (id) => id !== currentChatId && switchable(directory.rows.get(id), reachable),
+  );
+  const viewed = (currentChatId ? [currentChatId, ...recent] : recent).slice(0, SWITCHER_LIMIT);
+  const ids = [
+    ...viewed,
+    ...moreChats(directory, new Set(viewed), reachable, SWITCHER_LIMIT - viewed.length),
+  ];
   // Away from a chat (the inbox, a new chat) the most recent chat is the target.
   const first = currentChatId ? 1 : 0;
-  if (limited.length <= first) return null;
-  return { ids: limited, index: backwards ? limited.length - 1 : first, visible: false };
+  if (ids.length <= first) return null;
+  return {
+    ids,
+    viewed: viewed.length,
+    index: backwards ? ids.length - 1 : first,
+    visible: false,
+  };
+}
+
+/**
+ * Chats that loaded while the list is open join at its end, so nothing the
+ * person is looking at moves. The same state when there is nothing new.
+ */
+export function extendChatSwitcher(
+  state: ChatSwitcherState,
+  directory: SwitcherDirectory,
+  reachable: (workspaceId: string) => boolean = () => true,
+): ChatSwitcherState {
+  const more = moreChats(
+    directory,
+    new Set(state.ids),
+    reachable,
+    SWITCHER_LIMIT - state.ids.length,
+  );
+  return more.length === 0 ? state : { ...state, ids: [...state.ids, ...more] };
 }
 
 /** Tab moves down the list and Shift+Tab up, wrapping at the ends. */