@opengeni/react 6.1.0 → 7.0.0-canary.35585322809001

package/src/hooks/use-codex-accounts.ts

@@ -3,6 +3,7 @@ import type {
   CodexAccount,
   CodexAccountsResponse,
   CodexRotationSettings,
+  SessionCodexAccountsResponse,
   SessionEvent,
 } from "@opengeni/sdk";
 import { useOpenGeni, type ClientOverride } from "../provider";
@@ -25,6 +26,8 @@ export function isCodexAccountEvent(event: Pick<SessionEvent, "type">): boolean
     "turn.completed",
     "turn.failed",
     "turn.cancelled",
+    "turn.requires_action",
+    "session.status.changed",
   ].includes(event.type);
 }
 
@@ -32,11 +35,17 @@ export function isCodexAccountEvent(event: Pick<SessionEvent, "type">): boolean
  * The structural slice of the SDK client the Codex-accounts surface needs. Method
  * NAMES + SIGNATURES match `OpenGeniClient` so the real client satisfies it
  * directly; declared structurally (not a hard Pick) so a test/Geni client can
- * stand in. `getSession` reads the session's pin/last; `pinSessionCodexAccount`
+ * stand in. `listSessionCodexAccounts` reads the accepted selection and choices
+ * atomically; `pinSessionCodexAccount`
  * is the optional mutation (absent ⇒ the indicator hides the switch affordance).
  */
 export type CodexAccountsClientLike = {
   listCodexAccounts: (workspaceId: string) => Promise<CodexAccountsResponse>;
+  /** Required for session-scoped use; never fall back to another pool. */
+  listSessionCodexAccounts?: (
+    workspaceId: string,
+    sessionId: string,
+  ) => Promise<SessionCodexAccountsResponse>;
   getSession?: (
     workspaceId: string,
     sessionId: string,
@@ -65,18 +74,21 @@ export type UseCodexAccountsOptions = ClientOverride &
 
 export type UseCodexAccountsResult = {
   accounts: CodexAccount[];
-  /** The workspace ACTIVE account (used when a session is unpinned). */
+  /** The ACTIVE account for the retry pool, or current workspace pool for new work. */
   activeAccountId: string | null;
   /** The session's PINNED account (null ⇒ following workspace active). */
   pinnedAccountId: string | null;
   /** Current preference only; automatic allocation can choose another account. */
   effectiveAccountId: string | null;
   currentSelection: { credentialId: string | null; waiting: boolean } | null;
+  /** The accepted account can differ from the choices for the next turn. */
+  currentAccount: CodexAccount | null;
   switchAppliedTo: "waiting_turn" | "next_turn" | null;
   /** The account the session's last turn ACTUALLY ran on (the "Running on:" source). */
   lastAccountId: string | null;
   settings: CodexRotationSettings;
   loading: boolean;
+  error: Error | null;
   refresh: () => Promise<void>;
   /**
    * Trigger a LIVE batched /wham/usage refresh across all accounts, then re-read
@@ -101,6 +113,7 @@ const EMPTY_SETTINGS: CodexRotationSettings = {
 };
 
 type CodexAccountsState = {
+  currentAccount: CodexAccount | null;
   currentSelection: { credentialId: string | null; waiting: boolean } | null;
   accounts: CodexAccount[];
   activeAccountId: string | null;
@@ -110,6 +123,7 @@ type CodexAccountsState = {
 };
 
 const EMPTY_STATE: CodexAccountsState = {
+  currentAccount: null,
   currentSelection: null,
   accounts: [],
   activeAccountId: null,
@@ -119,8 +133,8 @@ const EMPTY_STATE: CodexAccountsState = {
 };
 
 /**
- * The workspace's Codex accounts + the per-workspace active pointer + (when
- * session-scoped) the session pin and last-ran-on account. Composed like
+ * The workspace's Codex accounts, or session-authorized retry/next-turn choices
+ * and accepted current account. Composed like
  * `useMachines`: slow polling (the realtime work is done by the
  * `codex.account.switched` event trigger) + a `pin` mutation.
  * Dual-consumer safe via the structural `CodexAccountsClientLike` surface.
@@ -132,25 +146,27 @@ export function useCodexAccounts(options: UseCodexAccountsOptions = {}): UseCode
   const sharedEvents = options.events;
 
   const load = useCallback(async (): Promise<CodexAccountsState> => {
-    const accountsP = codexClient.listCodexAccounts(workspaceId);
-    const sessionP =
-      sessionId && codexClient.getSession
-        ? codexClient.getSession(workspaceId, sessionId).catch(() => null)
-        : Promise.resolve(null);
-    const [acc, session] = await Promise.all([accountsP, sessionP]);
+    if (sessionId) {
+      if (!codexClient.listSessionCodexAccounts)
+        throw new Error("Session Codex account projection is unavailable");
+      return await codexClient.listSessionCodexAccounts(workspaceId, sessionId);
+    }
+    const acc = await codexClient.listCodexAccounts(workspaceId);
     return {
-      currentSelection: session?.codexCurrentSelection ?? null,
+      currentSelection: null,
+      currentAccount: null,
       accounts: acc.accounts,
       activeAccountId: acc.activeAccountId,
       settings: acc.settings,
-      pinnedAccountId: session?.codexPinnedCredentialId ?? null,
-      lastAccountId: session?.codexLastCredentialId ?? null,
+      pinnedAccountId: null,
+      lastAccountId: null,
     };
   }, [codexClient, workspaceId, sessionId]);
 
   const {
     data: loadedData,
     loading,
+    error,
     refresh,
   } = usePolledValue(load, {
     pollIntervalMs: options.pollIntervalMs,
@@ -212,10 +228,12 @@ export function useCodexAccounts(options: UseCodexAccountsOptions = {}): UseCode
     return result === true;
   }, [codexClient, workspaceId, runUsageMutation, refresh]);
 
-  const data = loadedData ?? EMPTY_STATE;
+  // Reauthorization failure must remove a previously visible session pool.
+  const data = (sessionId && error ? null : loadedData) ?? EMPTY_STATE;
   const effectiveAccountId = data.pinnedAccountId ?? data.activeAccountId;
 
   return {
+    currentAccount: data.currentAccount,
     currentSelection: data.currentSelection,
     switchAppliedTo:
       switchReceipt?.sessionId === sessionId ? (switchReceipt?.appliedTo ?? null) : null,
@@ -226,6 +244,7 @@ export function useCodexAccounts(options: UseCodexAccountsOptions = {}): UseCode
     lastAccountId: data.lastAccountId,
     settings: data.settings,
     loading,
+    error,
     refresh,
     refreshUsage,
     refreshingUsage,

package/src/hooks/use-composer.ts

@@ -1475,9 +1475,10 @@ export function useComposer(
               ...(wireInput.mcpCredentialUpdates
                 ? { mcpCredentialUpdates: wireInput.mcpCredentialUpdates }
                 : {}),
-              ...(wireInput.connectionAuthorities
-                ? { connectionAuthorities: wireInput.connectionAuthorities }
+              ...(wireInput.connectionAccounts
+                ? { connectionAccounts: wireInput.connectionAccounts }
                 : {}),
+
               ...(wireInput.personalResourceAttachment
                 ? { personalResourceAttachment: wireInput.personalResourceAttachment }
                 : {}),
@@ -1751,9 +1752,7 @@ export function useComposer(
             ...(input.mcpCredentialUpdates
               ? { mcpCredentialUpdates: input.mcpCredentialUpdates }
               : {}),
-            ...(input.connectionAuthorities
-              ? { connectionAuthorities: input.connectionAuthorities }
-              : {}),
+            ...(input.connectionAccounts ? { connectionAccounts: input.connectionAccounts } : {}),
             ...(input.personalResourceAttachment
               ? { personalResourceAttachment: input.personalResourceAttachment }
               : {}),

package/src/hooks/use-connect.ts

@@ -0,0 +1,23 @@
+import type { ConnectController } from "@opengeni/connect";
+import { useMemo, useSyncExternalStore } from "react";
+
+/** Internal consumers import the hook directly so setup surfaces stay lazy. */
+export function useConnect(controller: ConnectController) {
+  const snapshot = useSyncExternalStore(
+    controller.subscribe,
+    controller.getSnapshot,
+    controller.getSnapshot,
+  );
+  const actions = useMemo(
+    () => ({
+      begin: controller.begin.bind(controller),
+      recover: controller.recover.bind(controller),
+      refresh: controller.refresh.bind(controller),
+      waitForAction: controller.waitForAction.bind(controller),
+      advance: controller.advance.bind(controller),
+      cancel: controller.cancel.bind(controller),
+    }),
+    [controller],
+  );
+  return useMemo(() => ({ ...snapshot, ...actions }), [snapshot, actions]);
+}

package/src/hooks/use-session-events.ts

@@ -73,6 +73,9 @@ export type UseSessionEventsResult = {
    * "Jump to latest" when the tip is not in memory (history view).
    */
   jumpToLatest: () => Promise<void>;
+  /** Replace history with a bounded window containing this exact durable event. */
+  jumpToSequence: (sequence: number, options?: { signal?: AbortSignal }) => Promise<boolean>;
+  loadingTarget: boolean;
   error: Error | null;
 };
 
@@ -136,6 +139,8 @@ export function useSessionEvents(
   const replay = options.replay ?? "windowed";
   const fullReplay = replay === "full" || after !== 0;
   const streamKey = `${workspaceId}\u0000${sessionId ?? ""}\u0000${after}\u0000${fullReplay ? "full" : "windowed"}`;
+  const navigationIdentityRef = useRef({ client, streamKey, enabled });
+  navigationIdentityRef.current = { client, streamKey, enabled };
 
   const [eventWindow, setEventWindow] = useState<BrowserSessionEventWindow>(EMPTY_EVENT_WINDOW);
   const [connectionState, setConnectionState] = useState<SessionEventsConnectionState>("idle");
@@ -151,6 +156,8 @@ export function useSessionEvents(
   const [loadingNewer, setLoadingNewer] = useState(false);
   const [loadingOldest, setLoadingOldest] = useState(false);
   const [loadingLatest, setLoadingLatest] = useState(false);
+  const [loadingTarget, setLoadingTarget] = useState(false);
+  const loadingTargetRef = useRef(false);
   const [streamEpoch, setStreamEpoch] = useState(0);
   // "history" = reading a non-tip window; live SSE must not fill the gap.
   const [viewMode, setViewMode] = useState<"live" | "history">("live");
@@ -191,6 +198,8 @@ export function useSessionEvents(
     loadingOlderRef.current = false;
     loadingNewerRef.current = false;
     loadingOldestRef.current = false;
+    loadingTargetRef.current = false;
+    setLoadingTarget(false);
     setLoadingOlder(false);
     setLoadingNewer(false);
     setLoadingOldest(false);
@@ -525,6 +534,7 @@ export function useSessionEvents(
   ]);
 
   const navigationBusy = (): boolean =>
+    loadingTargetRef.current ||
     loadingOlderRef.current ||
     loadingNewerRef.current ||
     loadingOldestRef.current ||
@@ -826,7 +836,102 @@ export function useSessionEvents(
     }
   }, [client, workspaceId, sessionId]);
 
+  const jumpToSequence = useCallback(
+    async (sequence: number, navigationOptions?: { signal?: AbortSignal }): Promise<boolean> => {
+      const signal = navigationOptions?.signal;
+      if (!sessionId || !Number.isSafeInteger(sequence) || sequence < 1) return false;
+      // A navigation that was already cancelled (for example Find closed before
+      // the caller could react) must not disturb any current view state.
+      if (signal?.aborted) return false;
+      // Explicit targets supersede both other targets and adjacent-page requests.
+      const generation = ++navigationGenerationRef.current;
+      const current = () =>
+        generation === navigationGenerationRef.current &&
+        navigationIdentityRef.current.client === client &&
+        navigationIdentityRef.current.streamKey === streamKey &&
+        navigationIdentityRef.current.enabled === enabled;
+      const previousMode = viewModeRef.current;
+      streamAbortRef.current?.abort();
+      generationRef.current += 1;
+      viewModeRef.current = "history";
+      setViewMode("history");
+      loadingOlderRef.current = loadingNewerRef.current = loadingOldestRef.current = false;
+      setLoadingOlder(false);
+      setLoadingNewer(false);
+      setLoadingOldest(false);
+      loadingTargetRef.current = true;
+      setLoadingTarget(true);
+      let published = false;
+      try {
+        const [before, following] = await Promise.all([
+          loadPreviousPage(client, workspaceId, sessionId, sequence + 1, { pageSize: 128 }),
+          loadNextPage(client, workspaceId, sessionId, sequence, { pageSize: 128 }),
+        ]);
+        // Close-during-fetch fence: a pending jump must not replace the window
+        // after its owner (for example ConversationFind) has gone away. The
+        // finally block still settles loadingTarget for this generation.
+        if (signal?.aborted) return false;
+        if (!current()) return false;
+        if (!before.some((event) => event.sequence === sequence)) return false;
+        // Bound each side, keeping the target even if its message alone exceeds
+        // the ordinary byte budget. Never evict the very event being navigated to.
+        const prefix = boundBrowserSessionEventWindow(before, {
+          direction: "newest",
+          maxBytes: SESSION_EVENT_BROWSER_MAX_BYTES / 2,
+        });
+        const retained = boundBrowserSessionEventWindow([...prefix.events, ...following], {
+          direction: "oldest",
+        });
+        if (!retained.events.some((event) => event.sequence === sequence)) return false;
+        streamAbortRef.current?.abort();
+        generationRef.current += 1;
+        const status = observeSessionStatus(retained.events, sessionStatusRef);
+        eventWindowRef.current = retained;
+        oldestSequenceRef.current = retained.events[0]!.sequence;
+        newestSequenceRef.current = maxResumeSequenceOrNull(retained.events);
+        lastSequenceRef.current = Math.max(lastSequenceRef.current, newestSequenceRef.current ?? 0);
+        hasOlderRef.current = !isLogStart(retained.events[0]!);
+        // Compact/byte-bounded pages may be short despite more durable history.
+        // Only an empty forward page proves the end (same rule as loadNewer).
+        hasNewerRef.current =
+          following.length > 0 ||
+          retained.truncated ||
+          (newestSequenceRef.current ?? 0) < lastSequenceRef.current;
+        initialWindowLoadedRef.current = true;
+        viewModeRef.current = "history";
+        setEventWindow(retained);
+        setHasOlder(hasOlderRef.current);
+        setHasNewer(hasNewerRef.current);
+        setInitialLoading(false);
+        setViewMode("history");
+        setNewerError(null);
+        if (status !== undefined) setSessionStatusProjection(status);
+        published = true;
+        return true;
+      } catch (reason) {
+        if (!current() || signal?.aborted) return false;
+        throw reason;
+      } finally {
+        if (current()) {
+          loadingTargetRef.current = false;
+          setLoadingTarget(false);
+          if (!published && previousMode === "live") {
+            viewModeRef.current = "live";
+            setViewMode("live");
+            setStreamEpoch((epoch) => epoch + 1);
+          }
+        }
+      }
+    },
+    [client, workspaceId, sessionId, streamKey, enabled],
+  );
+
   const jumpToLatest = useCallback(async (): Promise<void> => {
+    if (loadingTargetRef.current) {
+      navigationGenerationRef.current += 1;
+      loadingTargetRef.current = false;
+      setLoadingTarget(false);
+    }
     if (!sessionId || navigationBusy()) {
       return;
     }
@@ -867,7 +972,13 @@ export function useSessionEvents(
 
   const identityMatches = stateStreamKey === streamKey;
   const visibleEvents = identityMatches ? eventWindow.events : EMPTY_EVENTS;
-  const timeline = useMemo(() => buildTimeline(visibleEvents), [visibleEvents]);
+  const timeline = useMemo(
+    () =>
+      buildTimeline(visibleEvents, {
+        partialStart: hasOlder || eventWindow.truncated || after > 0,
+      }),
+    [visibleEvents, hasOlder, eventWindow.truncated, after],
+  );
 
   return {
     events: visibleEvents,
@@ -889,6 +1000,8 @@ export function useSessionEvents(
     loadOldest,
     loadingLatest: !identityMatches ? false : loadingLatest,
     jumpToLatest,
+    jumpToSequence,
+    loadingTarget: identityMatches && loadingTarget,
     error: identityMatches ? (newerError ?? error) : null,
   };
 }

package/src/hooks/use-session-mcp-approval-policy.ts

@@ -1,7 +1,7 @@
 import type {
   SessionEvent,
   SessionMcpApprovalPolicy,
-  SessionMcpServerMetadata,
+  SessionMcpApprovalPolicyTarget,
   UpdateSessionMcpApprovalPolicyResponse,
 } from "@opengeni/sdk";
 import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from "react";
@@ -38,7 +38,7 @@ export type UseSessionMcpApprovalPolicyOptions = EmbeddedSessionMcpApprovalPolic
   };
 
 export type UseSessionMcpApprovalPolicyResult = {
-  server: SessionMcpServerMetadata | null;
+  server: SessionMcpApprovalPolicyTarget | null;
   policy: SessionMcpApprovalPolicy | null;
   loading: boolean;
   error: Error | null;
@@ -61,7 +61,7 @@ export function useSessionMcpApprovalPolicy(
 ): UseSessionMcpApprovalPolicyResult {
   const { client, workspaceId } = useEmbeddedSessionMcpApprovalPolicy(options);
   const enabled = (options.enabled ?? true) && Boolean(sessionId && serverId);
-  const [override, setOverride] = useState<SessionMcpServerMetadata | null>(null);
+  const [override, setOverride] = useState<SessionMcpApprovalPolicyTarget | null>(null);
   const targetKey = `${workspaceId}\u0000${sessionId ?? ""}\u0000${serverId ?? ""}`;
   const authoritativeGeneration = useRef(0);
   const mutationIdentity = useMemo(() => ({ client, targetKey }), [client, targetKey]);
@@ -75,7 +75,7 @@ export function useSessionMcpApprovalPolicy(
   type PolicyRead = {
     targetKey: string;
     generation: number;
-    server: SessionMcpServerMetadata | null;
+    server: SessionMcpApprovalPolicyTarget | null;
   };
   const load = useCallback(async (): Promise<PolicyRead> => {
     const generation = authoritativeGeneration.current;
@@ -86,7 +86,15 @@ export function useSessionMcpApprovalPolicy(
     return {
       targetKey,
       generation,
-      server: session.mcpServers.find((server) => server.id === serverId) ?? null,
+      server:
+        session.mcpServers.find((server) => server.id === serverId) ??
+        (session.mcpApprovalPolicies && Object.hasOwn(session.mcpApprovalPolicies, serverId)
+          ? {
+              id: serverId,
+              source: "workspace",
+              requireApproval: session.mcpApprovalPolicies[serverId]!,
+            }
+          : null),
     };
   }, [client, serverId, sessionId, targetKey, workspaceId]);
   const {

package/src/hooks/use-workspace-sessions.ts

@@ -11,6 +11,8 @@ export type UseWorkspaceSessionsOptions = ClientOverride & {
   /** Return only the complete personal pinned projection. */
   pinsOnly?: boolean | undefined;
   archivedOnly?: boolean | undefined;
+  sortBy?: "updatedAt" | "createdAt" | "name" | undefined;
+  archiveStatus?: "active" | "archived" | "all" | undefined;
   /** Refresh interval (ms) for fleet/manager views. Off by default. */
   pollIntervalMs?: number | undefined;
   enabled?: boolean | undefined;
@@ -49,6 +51,8 @@ export function useWorkspaceSessions(
   const search = options.search;
   const pinsOnly = options.pinsOnly;
   const archivedOnly = options.archivedOnly;
+  const sortBy = options.sortBy;
+  const archiveStatus = options.archiveStatus;
   const enabled = options.enabled ?? true;
   const nextReadRevision = useRef(0);
   const nextReadGeneration = useRef(0);
@@ -61,6 +65,8 @@ export function useWorkspaceSessions(
     search ?? "",
     pinsOnly ? "1" : "",
     archivedOnly ? "archived" : "active",
+    sortBy ?? "",
+    archiveStatus ?? "",
   ].join("\u0000");
   const previousQueryKey = useRef(queryKey);
   const queryKeyTransition = previousQueryKey.current !== queryKey;
@@ -77,6 +83,8 @@ export function useWorkspaceSessions(
         ...(search !== undefined ? { search } : {}),
         ...(pinsOnly ? { pinsOnly: true } : {}),
         ...(archivedOnly ? { archivedOnly: true } : {}),
+        ...(sortBy ? { sortBy } : {}),
+        ...(archiveStatus ? { archiveStatus } : {}),
         signal,
       });
       return {
@@ -96,6 +104,8 @@ export function useWorkspaceSessions(
       search,
       pinsOnly,
       archivedOnly,
+      sortBy,
+      archiveStatus,
       queryKey,
     ],
   );

package/src/index.ts

@@ -1,3 +1,22 @@
+export { sessionAuthRecommendation } from "./session-auth-recommendation";
+export {
+  SessionConnectionRequest,
+  type SessionConnectionRequestProps,
+} from "./components/session-connection-request";
+export {
+  SessionMcpCapabilityCard,
+  McpConnectionCard,
+  type McpConnectionCardProps,
+  type SessionMcpCapabilityCardProps,
+} from "./components/session-mcp-capability-card";
+export {
+  SessionCapabilityFrame,
+  type SessionCapabilityFrameProps,
+} from "./components/session-capability-frame";
+export {
+  attachSessionCapability,
+  completeSessionCapabilityOAuth,
+} from "./session-capability-policy";
 export { retainedImageId } from "./components/markdown";
 // oxlint-disable-next-line typescript/triple-slash-reference -- package consumers must load the ambient type for this optional untyped peer without emitting a runtime import.
 /// <reference path="./types/external.d.ts" />
@@ -217,8 +236,6 @@ export type {
   UseRigChangesOptions,
   UseRigChangesResult,
 } from "./hooks/use-rigs";
-export { usePacks } from "./hooks/use-packs";
-export type { UsePacksOptions, UsePacksResult } from "./hooks/use-packs";
 export { useWorkspaces } from "./hooks/use-workspaces";
 export type { UseWorkspacesOptions, UseWorkspacesResult } from "./hooks/use-workspaces";
 export { useBillingUsage } from "./hooks/use-billing-usage";
@@ -462,6 +479,7 @@ export type { CommandPaletteProps } from "./components/command-palette";
 
 // Components
 export { ChatComposer } from "./components/chat-composer";
+export { conversationTimeline } from "./conversation-timeline";
 export { SessionConversation } from "./components/session-conversation";
 export type { SessionConversationProps } from "./components/session-conversation";
 export type { ChatComposerProps } from "./components/chat-composer";
@@ -511,6 +529,7 @@ export { MessageTimeline, TimelineRow } from "./components/message-timeline";
 export { GeneratedVideoPlayer } from "./components/generated-video-player";
 export type { GeneratedVideoPlayerProps } from "./components/generated-video-player";
 export type { MessageTimelineProps } from "./components/message-timeline";
+export type { TimelineSearchTarget } from "./components/timeline-search";
 export { UserMessageBody, userMessageLikelyNeedsDisclosure } from "./components/user-message-body";
 export type {
   UserMessageBodyProps,
@@ -617,6 +636,7 @@ export {
   tryParseJson,
 } from "./lib/format";
 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";

package/src/mcp-connection-status.ts

@@ -0,0 +1,35 @@
+import type { CapabilityCatalogItem, ConnectionMetadata } from "@opengeni/sdk";
+
+/** Status only; runtime use is authorized for the authenticated initiating user. */
+export function matchingActiveMcpConnections(
+  item: CapabilityCatalogItem,
+  connections: ConnectionMetadata[],
+) {
+  return matchingMcpConnections(item, connections).filter((entry) => entry.status === "active");
+}
+
+function matchingMcpConnections(item: CapabilityCatalogItem, connections: ConnectionMetadata[]) {
+  const ref = item.connectionRef;
+  if (!item.enabled || !ref) return [];
+  return connections.filter(
+    (entry) =>
+      entry.status !== "revoked" &&
+      entry.kind === "oauth2" &&
+      entry.metadata.mcpUrl === (item.mcpUrl ?? item.endpointUrl) &&
+      (ref.subjectScope !== "subject"
+        ? entry.id === ref.connectionId && entry.subjectId === null
+        : entry.subjectId !== null),
+  );
+}
+
+/** Installation availability is not account readiness. Revoked history is not actionable. */
+export function mcpConnectionDiscoveryState(
+  item: CapabilityCatalogItem,
+  connections: ConnectionMetadata[],
+) {
+  const matching = matchingMcpConnections(item, connections);
+  const active = matching.filter((entry) => entry.status === "active");
+  if (active.length === 1) return { status: "added", label: "Connected" } as const;
+  if (matching.length > 0) return { status: "attention", label: "Review connection" } as const;
+  return { status: "available", label: "Connect" } as const;
+}

package/src/model-policy.ts

@@ -274,9 +274,11 @@ export function findPickerRow<TCatalog extends ClientModel>(
 
 export function groupPickerRowsByBillingClass(
   rows: PickerModelRow[],
+  options?: { codexOnly?: boolean },
 ): Array<{ billingClass: PickerBillingClass; label: string; rows: PickerModelRow[] }>;
 export function groupPickerRowsByBillingClass<TCatalog extends ClientModel>(
   rows: PickerModelRow<TCatalog>[],
+  options?: { codexOnly?: boolean },
 ): Array<{
   billingClass: PickerBillingClass;
   label: string;
@@ -284,6 +286,7 @@ export function groupPickerRowsByBillingClass<TCatalog extends ClientModel>(
 }>;
 export function groupPickerRowsByBillingClass<TCatalog extends ClientModel>(
   rows: PickerModelRow<TCatalog>[],
+  options?: { codexOnly?: boolean },
 ): Array<{
   billingClass: PickerBillingClass;
   label: string;
@@ -307,5 +310,23 @@ export function groupPickerRowsByBillingClass<TCatalog extends ClientModel>(
       rows: [row],
     });
   }
+  const codexIndex = groups.findIndex((group) => group.billingClass === "codex_subscription");
+  const codex = groups[codexIndex];
+  const selectableOpenGeni = groups
+    .find((group) => group.billingClass === "opengeni_credits")
+    ?.rows.filter((row) => row.selectable);
+  // Presentation only: never change the catalog/default model ordering or selection.
+  const onlyFreeOpenGeni =
+    selectableOpenGeni !== undefined &&
+    selectableOpenGeni.length > 0 &&
+    selectableOpenGeni.every((row) => row.catalog.cost === "free");
+  if (
+    codex &&
+    codex.rows.some((row) => row.selectable) &&
+    (options?.codexOnly || onlyFreeOpenGeni)
+  ) {
+    groups.splice(codexIndex, 1);
+    groups.unshift(codex);
+  }
   return groups;
 }

package/src/plugin-details.tsx

@@ -1,6 +1,8 @@
 import { useState } from "react";
 import { pluginMcpUnavailableReason, type PluginDiscoveryItem } from "@opengeni/sdk";
+import { BoxesIcon } from "lucide-react";
 import { Markdown } from "./components/markdown";
+import { ConnectionLogo } from "./connection-logo";
 
 const componentLabels: Record<string, string> = {
   skills: "Skills",
@@ -38,9 +40,8 @@ export function PluginDetails({
   const installableCount =
     (item.skills?.length ?? 0) + (item.mcpServers?.filter(supported).length ?? 0);
   const exceedsInstallLimit = installableCount > 64;
-  const installable = installableCount > 0 && !exceedsInstallLimit;
+  const installable = !contentsUnknown && installableCount > 0 && !exceedsInstallLimit;
   const [expanded, setExpanded] = useState(false);
-  const [logoFailed, setLogoFailed] = useState(false);
   const description = item.longDescription || item.description;
   const lengthy = description.length > 700;
   const registryLabel =
@@ -52,9 +53,11 @@ export function PluginDetails({
   return (
     <article className="og-plugin-details">
       <header className="og-plugin-details-header">
-        {item.logoUrl && !logoFailed ? (
-          <img src={item.logoUrl} alt="" onError={() => setLogoFailed(true)} />
-        ) : null}
+        <ConnectionLogo
+          src={item.logoUrl}
+          name={item.displayName}
+          fallback={<BoxesIcon aria-hidden="true" />}
+        />
         <div>
           <h2>{item.displayName.replace(/-/g, " ")}</h2>
           {item.author?.name ? <p>By {item.author.name}</p> : null}