@opengeni/react 4.6.1 → 4.6.2-canary.39853438886001

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

@@ -0,0 +1,314 @@
+import { describe, expect, test } from "bun:test";
+import {
+  showsSubscriptionAccountMenu,
+  subscriptionAccountMenuContent,
+  subscriptionAccountProvider,
+  subscriptionAccountUsage,
+  type SubscriptionAccount,
+  type SubscriptionAccountState,
+  type SubscriptionAccountUsage,
+} from "./subscription-account";
+
+const snapshot = (
+  windows: SubscriptionAccountUsage["windows"],
+  extra: Partial<SubscriptionAccountUsage> = {},
+): SubscriptionAccountUsage => ({
+  windows,
+  observedAt: null,
+  exhaustedUntil: null,
+  exhaustedKind: null,
+  ...extra,
+});
+
+function account(id: string, extra: Partial<SubscriptionAccount> = {}): SubscriptionAccount {
+  return {
+    id,
+    label: `Acme ${id}`,
+    email: `${id}@example.test`,
+    plan: "Pro",
+    source: "organization",
+    status: "active",
+    refusal: null,
+    choosable: true,
+    usage: snapshot(
+      [
+        { id: "five_hour", usedPercent: 36, resetsAt: null, status: "ok" },
+        { id: "seven_day", usedPercent: 62, resetsAt: null, status: "ok" },
+      ],
+      { observedAt: "2026-10-22T16:50:00Z" },
+    ),
+    ...extra,
+  };
+}
+
+function state(extra: Partial<SubscriptionAccountState> = {}): SubscriptionAccountState {
+  const accounts = [
+    account("a"),
+    account("b", { source: "workspace" }),
+    account("c", { status: "needs_relogin", choosable: false, refusal: "inactive", usage: null }),
+  ];
+  return {
+    provider: "claude",
+    loading: false,
+    unavailable: false,
+    accounts,
+    current: accounts[0]!,
+    currentHidden: false,
+    serving: false,
+    automatic: true,
+    chosenId: null,
+    waiting: false,
+    usageCheck: "idle",
+    choosing: false,
+    choosingTarget: undefined,
+    appliedTo: null,
+    mutationError: null,
+    ...extra,
+  };
+}
+
+describe("one menu for every subscription provider", () => {
+  test("Codex and Claude differ only in the provider name", () => {
+    const claude = subscriptionAccountMenuContent(state({ provider: "claude" }));
+    const codex = subscriptionAccountMenuContent(state({ provider: "codex" }));
+    const neutral = (value: unknown) => JSON.stringify(value).replaceAll(/Claude|Codex/g, "X");
+    expect(neutral(codex)).toBe(neutral(claude));
+    expect(claude.ariaLabel).toBe("Claude account · Acme a");
+    expect(codex.ariaLabel).toBe("Codex account · Acme a");
+  });
+
+  test("the current account shows its plan, owner, email and usage the same way", () => {
+    const content = subscriptionAccountMenuContent(state());
+    expect(content.selectionLabel).toBe("Current account");
+    expect(content.identity).toBe("a@example.test");
+    expect(content.metadata).toBe("Pro · Organization");
+    expect(content.usage.windows?.map((window) => [window.label, window.usedPercent])).toEqual([
+      ["5h", 36],
+      ["Week", 62],
+    ]);
+    expect(content.usage.note).toStartWith("Updated ");
+    expect(content.automaticLabel).toBe("Automatic");
+    expect(content.actionLabel).toBe("Use for next turn");
+    // Other accounts summarize each window; the current one is shown above.
+    expect(content.accounts.map((row) => row.usageSummary)).toEqual([
+      undefined,
+      "5h 36% · Week 62% used",
+      undefined,
+    ]);
+    expect(content.accounts[2]).toMatchObject({ status: "Needs reconnect", disabled: true });
+    expect(content.accounts[1]?.detail).toBe("Acme b · b@example.test · Pro · This workspace");
+  });
+
+  test("a turn waiting for capacity offers a retry for any provider", () => {
+    for (const provider of ["codex", "claude"]) {
+      const content = subscriptionAccountMenuContent(state({ provider, waiting: true }));
+      expect(content.selectionLabel).toBe("Limit reached");
+      expect(content.actionLabel).toBe("Retry with");
+      expect(content.tone).toBe("warn");
+      expect(content.note).toBe("Changing accounts retries the waiting turn.");
+    }
+  });
+
+  test("a chosen account this person cannot see keeps a way back to Automatic", () => {
+    const content = subscriptionAccountMenuContent(
+      state({ current: null, currentHidden: true, automatic: false, chosenId: null }),
+    );
+    expect(content.displayName).toBe("Account unavailable");
+    expect(content.selectionLabel).toBe("Chosen account");
+    expect(content.usage.message).toBe("Account usage hidden");
+    expect(content.automaticSelected).toBe(false);
+    expect(content.selectedId).toBeNull();
+  });
+
+  test("an explicit choice is checked and named as chosen", () => {
+    const content = subscriptionAccountMenuContent(state({ automatic: false, chosenId: "a" }));
+    expect(content.selectionLabel).toBe("Chosen account");
+    expect(content.selectedId).toBe("a");
+    expect(content.automaticSelected).toBe(false);
+  });
+
+  test("tone flags reconnects and windows near their limit", () => {
+    expect(
+      subscriptionAccountMenuContent(state({ current: account("x", { status: "needs_relogin" }) }))
+        .tone,
+    ).toBe("bad");
+    expect(
+      subscriptionAccountMenuContent(
+        state({
+          current: account("x", {
+            usage: snapshot([{ id: "five_hour", usedPercent: 95, resetsAt: null, status: "ok" }]),
+          }),
+        }),
+      ).tone,
+    ).toBe("warn");
+    expect(subscriptionAccountMenuContent(state()).tone).toBe("ok");
+  });
+
+  test("empty and failed reads say so in the same words", () => {
+    const empty = subscriptionAccountMenuContent(state({ accounts: [], current: null }));
+    expect(empty.emptyMessage).toBe("No accounts available.");
+    expect(empty.displayName).toBe("Automatic");
+    expect(empty.metadata).toBe("Claude subscription");
+    const failed = subscriptionAccountMenuContent(
+      state({ accounts: [], current: null, unavailable: true }),
+    );
+    expect(failed.emptyMessage).toBe("Accounts unavailable.");
+    // A failed read does not know the selection, so nothing claims Automatic.
+    expect(failed.displayName).toBe("Accounts unavailable");
+    expect(failed.selectionLabel).toBe("Account selection");
+    expect(failed.automaticSelected).toBe(false);
+    expect(failed.selectedId).toBeNull();
+    expect(failed.ariaLabel).toBe("Claude account · Accounts unavailable");
+    expect(subscriptionAccountMenuContent(state({ mutationError: "busy" })).error).toBe(
+      "Couldn't switch: busy",
+    );
+  });
+
+  test("a failed check on the current account keeps the other accounts' readings", () => {
+    const failed = subscriptionAccountMenuContent(state({ usageCheck: "failed" }));
+    expect(failed.accounts.map((row) => row.usageSummary)).toEqual([
+      undefined,
+      "5h 36% · Week 62% used",
+      undefined,
+    ]);
+  });
+
+  test("the serving account is the current account, even when another one is chosen", () => {
+    const hidden = subscriptionAccountMenuContent(
+      state({ current: null, currentHidden: true, serving: true, automatic: false, chosenId: "b" }),
+    );
+    expect(hidden.selectionLabel).toBe("Current account");
+    expect(hidden.displayName).toBe("Account unavailable");
+    expect(hidden.selectedId).toBe("b");
+    const visible = subscriptionAccountMenuContent(
+      state({ serving: true, automatic: false, chosenId: "a" }),
+    );
+    expect(visible.selectionLabel).toBe("Current account");
+  });
+
+  test("a chip near its limit says so to assistive technology", () => {
+    const near = subscriptionAccountMenuContent(
+      state({
+        current: account("a", {
+          usage: snapshot([
+            { id: "five_hour", usedPercent: 95, resetsAt: null, status: "warning" },
+          ]),
+        }),
+      }),
+    );
+    expect(near.ariaLabel).toBe("Claude account · Acme a · Near its limit");
+  });
+
+  test("with nothing to choose or show, only the provider mark remains", () => {
+    expect(showsSubscriptionAccountMenu(state({ accounts: [], current: null }))).toBe(false);
+    expect(showsSubscriptionAccountMenu(state())).toBe(true);
+    for (const extra of [
+      { unavailable: true },
+      { currentHidden: true },
+      { waiting: true },
+      { automatic: false },
+    ]) {
+      expect(showsSubscriptionAccountMenu(state({ accounts: [], current: null, ...extra }))).toBe(
+        true,
+      );
+    }
+  });
+
+  test("a live check hides readings until it answers", () => {
+    const checking = subscriptionAccountMenuContent(state({ usageCheck: "checking" }));
+    expect(checking.usage).toEqual({ checking: true });
+    expect(checking.accounts.every((row) => row.usageSummary === undefined)).toBe(true);
+    expect(subscriptionAccountMenuContent(state({ usageCheck: "failed" })).usage).toEqual({
+      unavailable: true,
+    });
+  });
+});
+
+describe("usage readings", () => {
+  test("a limit whose end has passed no longer reads as reached", () => {
+    const ended = snapshot([], {
+      exhaustedUntil: "2026-10-22T10:00:00Z",
+      exhaustedKind: "quota",
+    });
+    expect(subscriptionAccountUsage(ended, Date.parse("2026-10-22T11:00:00Z")).message).toBe(
+      "No usage reading yet",
+    );
+    expect(subscriptionAccountUsage(ended, Date.parse("2026-10-22T09:00:00Z")).message).toStartWith(
+      "Limit reached until ",
+    );
+  });
+
+  test("missing readings and empty snapshots say there is no reading yet", () => {
+    expect(subscriptionAccountUsage(undefined).message).toBe("No usage reading yet");
+    expect(subscriptionAccountUsage(null).message).toBe("No usage reading yet");
+    const empty = subscriptionAccountUsage(snapshot([]));
+    expect(empty).toMatchObject({ message: "No usage reading yet", windows: [] });
+    expect(empty.note).toBeUndefined();
+  });
+
+  test("partial and unknown windows are never completed, aggregated or given a made-up percent", () => {
+    const view = subscriptionAccountUsage(
+      snapshot([
+        { id: "seven_day_opus", usedPercent: null, resetsAt: null, status: "unknown" },
+        { id: "overage", usedPercent: 125, resetsAt: null, status: "unknown" },
+        { id: "custom", usedPercent: 8, resetsAt: null, status: "warning" },
+      ]),
+    );
+    expect(view.windows?.map((window) => window.usedPercent)).toEqual([null, 125, 8]);
+    expect(view.windows?.map((window) => window.label)).toEqual([
+      "Week · Opus",
+      "Overage",
+      "custom",
+    ]);
+    expect(view.summary).toBe("Week · Opus unknown · Overage 125% · custom 8% used");
+    expect(view.windows?.[0]?.detail).toContain("Status unknown");
+    expect(view.windows?.[2]?.detail).toContain("Near its limit");
+  });
+
+  test("neutral primary/secondary ids do not claim a window length", () => {
+    const view = subscriptionAccountUsage(
+      snapshot([{ id: "primary", usedPercent: 10, resetsAt: null, status: "ok" }]),
+    );
+    expect(view.windows?.[0]?.label).toBe("Primary");
+  });
+
+  test("an account-wide limit without windows names when it ends", () => {
+    const view = subscriptionAccountUsage(
+      snapshot([], { exhaustedKind: "rate_limit", exhaustedUntil: "2020-01-01T09:00:00Z" }),
+      Date.parse("2020-01-01T08:00:00Z"),
+    );
+    expect(view.message).toStartWith("Limit reached until ");
+    expect(view.windows).toEqual([]);
+  });
+
+  test("a past reset keeps the reading but says it may be outdated", () => {
+    const value = snapshot([
+      { id: "five_hour", usedPercent: 100, resetsAt: "2026-10-12T12:00:00Z", status: "exhausted" },
+    ]);
+    const before = subscriptionAccountUsage(value, Date.parse("2026-10-12T11:00:00Z"));
+    const after = subscriptionAccountUsage(value, Date.parse("2026-10-12T13:00:00Z"));
+    expect(before.windows?.[0]?.detail).toContain("Resets ");
+    expect(after.windows?.[0]?.detail).toContain("Reset passed; usage may be outdated");
+    expect(after.windows?.[0]?.detail).toContain("Limit reached");
+    expect(after.windows?.[0]?.usedPercent).toBe(100);
+  });
+});
+
+describe("which subscription a chat offers accounts for", () => {
+  test("Codex product models, then the catalog's connected subscription", () => {
+    expect(subscriptionAccountProvider("codex/gpt-6-astra", undefined)).toBe("codex");
+    expect(
+      subscriptionAccountProvider("organization-claude-subscription/claude-opus-5-5", {
+        kind: "connected_subscription",
+        provider: "claude",
+      }),
+    ).toBe("claude");
+    expect(
+      subscriptionAccountProvider("supergrok/grok-4.6", {
+        kind: "connected_subscription",
+        provider: "xai",
+      }),
+    ).toBe("xai");
+    expect(subscriptionAccountProvider("gpt-5.6-sol", undefined)).toBeNull();
+  });
+});

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)}
           />