@opengeni/react 4.6.1 → 4.6.2-canary.39854174564001

package/src/app/lib/drive-connect-return.test.ts

@@ -0,0 +1,183 @@
+import { expect, mock, test } from "bun:test";
+import type { OpenGeniBrowserClient } from "@opengeni/sdk/browser";
+import {
+  beginDriveConnect,
+  resolveDriveConnectReturn,
+  completeDriveConnectReturn,
+} from "./drive-connect-return";
+
+function fixture() {
+  const values = new Map<string, string>();
+  const storage = {
+    getItem: (key: string) => values.get(key) ?? null,
+    setItem: (key: string, value: string) => {
+      values.set(key, value);
+    },
+    removeItem: (key: string) => {
+      values.delete(key);
+    },
+  };
+  let outcome = {
+    id: "attempt",
+    providerId: "google-drive",
+    ownership: "personal",
+    state: "complete",
+    credentialsCommitted: true,
+    account: { id: "exact-account", providerId: "google-drive", ownership: "personal" },
+  } as Record<string, unknown>;
+  const beginConnect = mock(async () => ({
+    id: "attempt",
+    revision: 1,
+    state: "credential_input",
+  }));
+  const advanceConnectAttempt = mock(async () => ({
+    id: "attempt",
+    nextAction: { type: "authorize", url: "https://accounts.google.com/consent" },
+  }));
+  const getConnectAttempt = mock(async () => outcome);
+  const client = {
+    beginConnect,
+    connectTransport: () => ({ advance: advanceConnectAttempt, get: getConnectAttempt }),
+  } as unknown as OpenGeniBrowserClient;
+  return {
+    storage,
+    values,
+    client,
+    beginConnect,
+    advanceConnectAttempt,
+    getConnectAttempt,
+    setOutcome: (value: Record<string, unknown>) => {
+      outcome = value;
+    },
+  };
+}
+
+test("Drive return reads the exact durable account, scoped to its original workspace and return nonce", async () => {
+  const f = fixture();
+  expect(
+    await beginDriveConnect({
+      client: f.client,
+      workspaceId: "display",
+      connectionWorkspaceId: "owner",
+      itemId: "drive",
+      reconnectAccountId: "existing",
+      returnUrl: "https://app.example/settings?connect_item=drive",
+      storage: f.storage,
+    }),
+  ).toBe("https://accounts.google.com/consent");
+  expect(f.beginConnect).toHaveBeenCalledWith(
+    "owner",
+    expect.objectContaining({
+      providerId: "google-drive",
+      ownership: "personal",
+      reconnectAccountId: "existing",
+    }),
+  );
+  expect(f.advanceConnectAttempt).toHaveBeenCalledWith(
+    "owner",
+    "attempt",
+    expect.objectContaining({ expectedRevision: 1, action: { type: "credentials", values: {} } }),
+  );
+  const receipt = JSON.parse([...f.values.values()][0]!);
+  await expect(
+    resolveDriveConnectReturn({
+      client: f.client,
+      workspaceId: "display",
+      nonce: "wrong",
+      storage: f.storage,
+    }),
+  ).rejects.toThrow("could not be matched");
+  expect(f.getConnectAttempt).not.toHaveBeenCalled();
+  await expect(
+    resolveDriveConnectReturn({
+      client: f.client,
+      workspaceId: "other",
+      nonce: receipt.nonce,
+      storage: f.storage,
+    }),
+  ).rejects.toThrow("could not be matched");
+  expect(
+    await resolveDriveConnectReturn({
+      client: f.client,
+      workspaceId: "display",
+      nonce: receipt.nonce,
+      storage: f.storage,
+    }),
+  ).toEqual({ itemId: "drive", connectionId: "exact-account" });
+  expect(f.getConnectAttempt).toHaveBeenCalledWith("owner", "attempt");
+  // StrictMode/effect cleanup can discard the first reader. The locator remains
+  // until its active consumer confirms the connector was enabled.
+  expect(
+    await resolveDriveConnectReturn({
+      client: f.client,
+      workspaceId: "display",
+      nonce: receipt.nonce,
+      storage: f.storage,
+    }),
+  ).toEqual({ itemId: "drive", connectionId: "exact-account" });
+  completeDriveConnectReturn("display", "different-return", f.storage);
+  expect(f.values.size).toBe(1);
+  completeDriveConnectReturn("display", receipt.nonce, f.storage);
+  expect(f.values.size).toBe(0);
+});
+
+test("failed or incomplete Drive returns never produce an account to auto-enable", async () => {
+  for (const state of ["failed", "requires_user_action", "complete"]) {
+    const f = fixture();
+    await beginDriveConnect({
+      client: f.client,
+      workspaceId: "workspace",
+      itemId: "drive",
+      returnUrl: "https://app.example/settings",
+      storage: f.storage,
+    });
+    const receipt = JSON.parse([...f.values.values()][0]!);
+    f.setOutcome({
+      id: "attempt",
+      providerId: "google-drive",
+      ownership: "personal",
+      state,
+      credentialsCommitted: false,
+      error: { message: "Provider rejected access" },
+    });
+    await expect(
+      resolveDriveConnectReturn({
+        client: f.client,
+        workspaceId: "workspace",
+        nonce: receipt.nonce,
+        storage: f.storage,
+      }),
+    ).rejects.toThrow();
+    expect(f.values.size).toBe(state === "failed" ? 0 : 1);
+  }
+});
+
+test("a different provider or ownership cannot satisfy a saved Drive return", async () => {
+  for (const patch of [{ providerId: "mcp-oauth" }, { ownership: "workspace" }]) {
+    const f = fixture();
+    await beginDriveConnect({
+      client: f.client,
+      workspaceId: "workspace",
+      itemId: "drive",
+      returnUrl: "https://app.example/settings",
+      storage: f.storage,
+    });
+    const receipt = JSON.parse([...f.values.values()][0]!);
+    f.setOutcome({
+      id: "attempt",
+      providerId: "google-drive",
+      ownership: "personal",
+      state: "complete",
+      credentialsCommitted: true,
+      ...patch,
+    });
+    await expect(
+      resolveDriveConnectReturn({
+        client: f.client,
+        workspaceId: "workspace",
+        nonce: receipt.nonce,
+        storage: f.storage,
+      }),
+    ).rejects.toThrow("account changed");
+  }
+});

package/src/app/lib/drive-connect-return.tsx

@@ -0,0 +1,116 @@
+import type { OpenGeniBrowserClient } from "@opengeni/sdk/browser";
+
+export const DRIVE_MCP_URL = "https://drivemcp.googleapis.com/mcp/v1";
+export const DRIVE_CONNECT_RETURN_PARAM = "drive_connect_return";
+const storageKey = (workspaceId: string) => `opengeni.drive-connect.v1:${workspaceId}`;
+type Receipt = { nonce: string; attemptId: string; connectionWorkspaceId: string; itemId: string };
+type Storage = Pick<globalThis.Storage, "getItem" | "setItem" | "removeItem">;
+
+/** Browser state is only a locator. Completion and the account come from Connect. */
+export async function beginDriveConnect(input: {
+  client: Pick<OpenGeniBrowserClient, "beginConnect" | "connectTransport">;
+  workspaceId: string;
+  connectionWorkspaceId?: string;
+  itemId: string;
+  reconnectAccountId?: string;
+  returnUrl: string;
+  storage: Storage;
+}): Promise<string> {
+  const nonce = crypto.randomUUID();
+  const returnUrl = new URL(input.returnUrl);
+  returnUrl.searchParams.set(DRIVE_CONNECT_RETURN_PARAM, nonce);
+  const connectionWorkspaceId = input.connectionWorkspaceId ?? input.workspaceId;
+  const created = await input.client.beginConnect(connectionWorkspaceId, {
+    providerId: "google-drive",
+    ownership: "personal",
+    returnUrl: returnUrl.toString(),
+    idempotencyKey: crypto.randomUUID(),
+    ...(input.reconnectAccountId ? { reconnectAccountId: input.reconnectAccountId } : {}),
+  });
+  if (created.state !== "credential_input")
+    throw new Error("Google Drive setup did not start. Try again.");
+  const attempt = await input.client.connectTransport().advance(connectionWorkspaceId, created.id, {
+    expectedRevision: created.revision,
+    idempotencyKey: crypto.randomUUID(),
+    action: { type: "credentials", values: {} },
+  });
+  if (attempt.nextAction.type !== "authorize")
+    throw new Error(attempt.error?.message ?? "Google Drive did not return an authorization link.");
+  input.storage.setItem(
+    storageKey(input.workspaceId),
+    JSON.stringify({
+      nonce,
+      attemptId: attempt.id,
+      connectionWorkspaceId,
+      itemId: input.itemId,
+    } satisfies Receipt),
+  );
+  return attempt.nextAction.url;
+}
+
+export async function resolveDriveConnectReturn(input: {
+  client: Pick<OpenGeniBrowserClient, "connectTransport">;
+  workspaceId: string;
+  nonce: string;
+  storage: Storage;
+}): Promise<{ itemId: string; connectionId: string }> {
+  const key = storageKey(input.workspaceId);
+  const raw = input.storage.getItem(key);
+  let receipt: Receipt;
+  try {
+    receipt = JSON.parse(raw ?? "null");
+    if (
+      !receipt ||
+      receipt.nonce !== input.nonce ||
+      ![receipt.attemptId, receipt.connectionWorkspaceId, receipt.itemId].every(
+        (value) => typeof value === "string" && value.length > 0 && value.length <= 4096,
+      )
+    )
+      throw new Error();
+  } catch {
+    throw new Error(
+      "The Google Drive setup return could not be matched. Open Drive to check your connection.",
+    );
+  }
+  const attempt = await input.client
+    .connectTransport()
+    .get(receipt.connectionWorkspaceId, receipt.attemptId);
+  if (
+    attempt.id !== receipt.attemptId ||
+    attempt.providerId !== "google-drive" ||
+    attempt.ownership !== "personal"
+  ) {
+    throw new Error("The Google Drive setup account changed. Open Drive to try again.");
+  }
+  if (["failed", "expired", "cancelled"].includes(attempt.state)) {
+    input.storage.removeItem(key);
+    throw new Error(
+      attempt.error?.message ??
+        "Google Drive connection was not completed. Open Drive to try again.",
+    );
+  }
+  if (
+    attempt.state !== "complete" ||
+    !attempt.credentialsCommitted ||
+    attempt.account?.providerId !== "google-drive" ||
+    attempt.account.ownership !== "personal" ||
+    !attempt.account.id
+  ) {
+    throw new Error("Google Drive setup is still incomplete. Reload to check it again.");
+  }
+  return { itemId: receipt.itemId, connectionId: attempt.account.id };
+}
+
+/** Clear only after the UI has finished enabling; never consume a newer attempt. */
+export function completeDriveConnectReturn(
+  workspaceId: string,
+  nonce: string,
+  storage: Storage,
+): void {
+  const key = storageKey(workspaceId);
+  try {
+    if (JSON.parse(storage.getItem(key) ?? "null")?.nonce === nonce) storage.removeItem(key);
+  } catch {
+    /* An absent or replaced browser locator grants no authority. */
+  }
+}

package/src/app/routes/session.tsx

@@ -57,6 +57,7 @@ import {
 // composer. Enter queues and Cmd/Ctrl+Enter steers; failed sessions stay
 // honest (reason + retry history) and revivable from the same composer.
 import { LightboxProvider } from "../../timeline";
+import { connectorLogo, connectorLogoIndex } from "../../timeline/connector-logo-index";
 import { sessionAdmissionBlocked, sessionDisplayStatus } from "../../session-status-model";
 import { useSessionSecrets } from "../../hooks/use-vaults";
 import type { WorkspaceTab } from "../../components/workspace-dock";
@@ -182,7 +183,6 @@ import type {
   SessionEditableArtifactsStatus,
 } from "../components/session/editable-artifacts-workspace";
 import {
-  normalizeProviderDomain,
   oauthConnectionOwnership,
   oauthConnectionRef,
   catalogConnectionAccountSelection,
@@ -1159,20 +1159,15 @@ export function SessionRoute({
   // The workspace shell already needs the capability catalog for session tool
   // policy. Reuse that authoritative read for timeline logos instead of
   // downloading the same large catalog again from the session route.
-  const providerLogos = useMemo(() => {
-    const logos = new Map<string, string>();
-    for (const capability of context.workspaceCapabilityCatalog) {
-      const domain = capability.providerDomain ?? capability.connectionRef?.providerDomain ?? null;
-      const url = context.client.catalogAssetUrl(capability.logoAssetPath);
-      if (domain && url) {
-        const key = normalizeProviderDomain(domain);
-        if (!logos.has(key)) logos.set(key, url);
-      }
-    }
-    return logos;
-  }, [context.client, context.workspaceCapabilityCatalog]);
+  const providerLogos = useMemo(
+    () =>
+      connectorLogoIndex(context.workspaceCapabilityCatalog, (path) =>
+        context.client.catalogAssetUrl(path ?? null),
+      ),
+    [context.client, context.workspaceCapabilityCatalog],
+  );
   const resolveProviderLogo = useCallback(
-    (domain: string) => providerLogos.get(normalizeProviderDomain(domain)) ?? null,
+    (domain: string) => connectorLogo(providerLogos, domain),
     [providerLogos],
   );
   // One lineage read feeds the single composer-anchored agents surface. Events
@@ -4027,6 +4022,9 @@ function SessionChatPane(props: {
                       sessionKey={props.session.id}
                       menuSide="top"
                       connectModelsHref={`/workspaces/${encodeURIComponent(props.session.workspaceId)}/settings?section=models`}
+                      claudeSubscriptionAvailable={
+                        context.clientConfig.claudeSubscriptionEnabled === true
+                      }
                       codexOnly={props.session.codexCompactionMode === "remote_v2"}
                       onModelChange={composer.setModel}
                       onEffortChange={composer.setReasoningEffort}

package/src/app/routes/sessions-index.tsx

@@ -2228,6 +2228,7 @@ function SessionModelControl({
       error={modelCatalog.error ?? policyError}
       menuSide="bottom"
       connectModelsHref={`/workspaces/${encodeURIComponent(workspaceId)}/settings?section=models`}
+      claudeSubscriptionAvailable={context.clientConfig.claudeSubscriptionEnabled === true}
       onModelChange={(model) => {
         onPolicyChosen();
         context.setModel(model);

package/src/components/model-policy-picker-menu.tsx

@@ -181,7 +181,11 @@ export function ModelPolicyPickerMenu(props: ModelPolicyPickerProps) {
             ) : null}
           </>
         ) : props.connectModelsHref || rows.length > 0 ? (
-          <ConnectModelsPanel href={props.connectModelsHref} messages={messages} />
+          <ConnectModelsPanel
+            href={props.connectModelsHref}
+            claude={props.claudeSubscriptionAvailable === true}
+            messages={messages}
+          />
         ) : (
           <p className={MENU_NOTE_CLASS}>{messages.noModels}</p>
         )}
@@ -204,8 +208,14 @@ export function ModelPolicyPickerMenu(props: ModelPolicyPickerProps) {
 
 const CONNECT_MODEL_OPTIONS = (
   t: OpenGeniText,
+  claude: boolean,
 ): Array<{
-  billingClass: "codex_subscription" | "supergrok_subscription" | "byok" | "external";
+  billingClass:
+    | "codex_subscription"
+    | "claude_subscription"
+    | "supergrok_subscription"
+    | "byok"
+    | "external";
   title: string;
   detail: string;
 }> => [
@@ -214,6 +224,15 @@ const CONNECT_MODEL_OPTIONS = (
     title: t("modelPolicyPickerMenu.codex"),
     detail: "ChatGPT",
   },
+  ...(claude
+    ? [
+        {
+          billingClass: "claude_subscription" as const,
+          title: t("modelPolicyPicker.claude"),
+          detail: "Anthropic",
+        },
+      ]
+    : []),
   { billingClass: "supergrok_subscription", title: "SuperGrok", detail: "xAI" },
   {
     billingClass: "byok",
@@ -225,6 +244,7 @@ const CONNECT_MODEL_OPTIONS = (
 
 function ConnectModelsPanel(props: {
   href: string | undefined;
+  claude: boolean;
   messages: ReturnType<typeof defaultModelPolicyPickerMessages>;
 }) {
   const t = useOpenGeniText();
@@ -239,7 +259,7 @@ function ConnectModelsPanel(props: {
         </p>
       </div>
       <div className="grid grid-cols-2 gap-1">
-        {CONNECT_MODEL_OPTIONS(t).map((option) => {
+        {CONNECT_MODEL_OPTIONS(t, props.claude).map((option) => {
           const content = (
             <>
               <span className="flex size-8 shrink-0 items-center justify-center rounded-og-md bg-og-surface-2 text-og-fg">
@@ -260,7 +280,8 @@ function ConnectModelsPanel(props: {
             </>
           );
           const className =
-            "flex min-w-0 items-center gap-2 rounded-og-md px-1.5 py-1.5 outline-hidden transition-colors hover:bg-og-hover focus-visible:ring-2 focus-visible:ring-og-accent/40";
+            // An odd last tile spans both columns instead of sitting alone.
+            "flex min-w-0 items-center gap-2 rounded-og-md px-1.5 py-1.5 outline-hidden transition-colors odd:last:col-span-2 hover:bg-og-hover focus-visible:ring-2 focus-visible:ring-og-accent/40";
           return props.href ? (
             <a key={option.title} href={props.href} className={className}>
               {content}

package/src/components/model-policy-picker.tsx

@@ -96,6 +96,8 @@ export type ModelPolicyPickerProps = {
   allowModelOptions?: boolean | undefined;
   /** Settings → Models. Shown when the catalog has no model that can run. */
   connectModelsHref?: string | undefined;
+  /** The deployment offers Claude subscriptions; the connect panel lists Claude too. */
+  claudeSubscriptionAvailable?: boolean | undefined;
   /** Classes for the portalled menu surface. Prefer --og-* tokens for theming. */
   contentClassName?: string | undefined;
   /** Inline styles for the portalled menu, applied after inherited --og-* tokens. */

package/src/components/session-mcp-capability-card.tsx

@@ -83,7 +83,7 @@ function ScopedCard({
   onConfigured,
   dialogOnly = false,
   onClose,
-  personalOnly = false,
+  personalOnly: configuredPersonalOnly = false,
   connectLabel,
   dialogSubtitle,
   description: hostDescription,
@@ -96,6 +96,9 @@ function ScopedCard({
   );
   const view = useConnect(controller);
   const [item, setItem] = useState<CapabilityCatalogItem | null>(null);
+  const personalOnly =
+    configuredPersonalOnly ||
+    (item?.mcpUrl ?? item?.endpointUrl) === "https://drivemcp.googleapis.com/mcp/v1";
   const [logo, setLogo] = useState<string | null>(null);
   const [expanded, setExpanded] = useState(dialogOnly);
   const [complete, setComplete] = useState(false);
@@ -151,7 +154,9 @@ function ScopedCard({
       setOwnership(resolved.connectionRef.subjectScope === "subject" ? "personal" : "workspace");
     else if (
       !item &&
-      (personalOnly || resolved.metadata?.defaultConnectionOwnership === "personal")
+      (personalOnly ||
+        (resolved.mcpUrl ?? resolved.endpointUrl) === "https://drivemcp.googleapis.com/mcp/v1" ||
+        resolved.metadata?.defaultConnectionOwnership === "personal")
     )
       setOwnership("personal");
     let accountReady = false;
@@ -399,7 +404,8 @@ function ScopedCard({
         }
         startInput.current = input;
         let attempt = await controller.begin({
-          providerId: "mcp-oauth",
+          providerId:
+            mcpUrl === "https://drivemcp.googleapis.com/mcp/v1" ? "google-drive" : "mcp-oauth",
           ownership,
           returnUrl,
           idempotencyKey: startKey.current,
@@ -409,7 +415,10 @@ function ScopedCard({
         remember(attempt.id);
         if (attempt.state === "credential_input")
           attempt = await controller.advance(
-            { type: "credentials", values: { mcpUrl } },
+            {
+              type: "credentials",
+              values: mcpUrl === "https://drivemcp.googleapis.com/mcp/v1" ? {} : { mcpUrl },
+            },
             advanceKey.current,
           );
         if (!active()) return;

package/src/connection-service-presentation.ts

@@ -4,7 +4,12 @@ import gmailLogo from "./assets/gmail.ico";
 import outlookLogo from "./assets/outlook.ico";
 
 /** Passive service identity only. Never selects an account or grants tool access. */
-const services: Record<string, { name: string; logo: string; mcpUrl?: string }> = {
+const services: Record<string, { name: string; logo: string | null; mcpUrl?: string }> = {
+  "google-drive": {
+    name: "Google Drive",
+    logo: null,
+    mcpUrl: "https://drivemcp.googleapis.com/mcp/v1",
+  },
   gmail: { name: "Gmail", logo: gmailLogo, mcpUrl: "https://gmailmcp.googleapis.com/mcp/v1" },
   "microsoft-outlook-mail": { name: "Outlook Mail", logo: outlookLogo },
   "microsoft-outlook-calendar": { name: "Outlook Calendar", logo: outlookLogo },

package/src/messages/en.ts

@@ -1817,7 +1817,7 @@ export const englishMessages = {
   "modelPolicy.billedToTheWorkspaceProvider": "Billed to the workspace provider account",
   "modelPolicy.billedToTheWorkspaceVercel": "Billed to the workspace Vercel account",
   "modelPolicy.blockedByWorkspacePolicy": "Blocked by workspace policy",
-  "modelPolicy.claudeSubscription": "Claude subscription",
+  "modelPolicy.claudeSubscription": "Claude",
   "modelPolicy.claudeSubscriptionExternalBilling": "Claude subscription · external billing",
   "modelPolicy.codex": "Codex",
   "modelPolicy.codexSubscriptionExternalBilling": "Codex subscription · external billing",

package/src/timeline/connector-logo-index.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, test } from "bun:test";
+
+import { connectorLogo, connectorLogoIndex } from "./connector-logo-index";
+
+const url = (path: string | null | undefined) => (path ? `/v1/${path}` : null);
+
+describe("connectorLogoIndex", () => {
+  test("a connector's server host finds the provider's logo", () => {
+    const index = connectorLogoIndex(
+      [
+        {
+          providerDomain: "linear.app",
+          mcpUrl: "https://mcp.linear.app/mcp",
+          logoAssetPath: "logos/linear.png",
+        },
+        {
+          providerDomain: "notion.com",
+          connectionRef: { providerDomain: "mcp.notion.com" },
+          logoAssetPath: "logos/notion.png",
+        },
+      ],
+      url,
+    );
+    expect(connectorLogo(index, "mcp.linear.app")).toBe("/v1/logos/linear.png");
+    expect(connectorLogo(index, "Linear.app")).toBe("/v1/logos/linear.png");
+    expect(connectorLogo(index, "mcp.notion.com")).toBe("/v1/logos/notion.png");
+    expect(connectorLogo(index, "example.com")).toBeNull();
+  });
+
+  test("a provider's own domain wins over another entry's server host", () => {
+    const index = connectorLogoIndex(
+      [
+        {
+          providerDomain: "relay.example",
+          mcpUrl: "https://github.com/mcp",
+          logoAssetPath: "logos/relay.png",
+        },
+        { providerDomain: "github.com", logoAssetPath: "logos/github.png" },
+        { providerDomain: "nologo.app", logoAssetPath: null },
+      ],
+      url,
+    );
+    expect(connectorLogo(index, "github.com")).toBe("/v1/logos/github.png");
+    expect(connectorLogo(index, "nologo.app")).toBeNull();
+  });
+});

package/src/timeline/connector-logo-index.ts

@@ -0,0 +1,68 @@
+/*
+ * Which logo belongs to a connector domain. Tool steps and sign-in cards name
+ * their connector by the domain of the connection or MCP server they used
+ * (Linear's is mcp.linear.app), while the catalog files the logo under the
+ * provider's own domain (linear.app). Indexing every domain a catalog entry is
+ * known by lets any of them find the logo. Framework-neutral, so web, native
+ * and embedded surfaces resolve logos the same way.
+ */
+
+/** The catalog fields that name a connector's domains and logo. */
+export type ConnectorLogoSource = {
+  providerDomain?: string | null | undefined;
+  mcpUrl?: string | null | undefined;
+  connectionRef?: { providerDomain?: string | null | undefined } | null | undefined;
+  logoAssetPath?: string | null | undefined;
+};
+
+/** "WWW.Linear.app " → "linear.app". */
+export function normalizeConnectorDomain(domain: string): string {
+  return domain
+    .trim()
+    .toLowerCase()
+    .replace(/^www\./, "");
+}
+
+function urlHost(url: string | null | undefined): string | null {
+  if (!url) return null;
+  try {
+    return new URL(url).hostname || null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Every domain each catalog entry is known by, mapped to its logo URL. The
+ * provider's own domain is claimed first across the whole catalog, so another
+ * entry's server host never takes over a provider's logo.
+ */
+export function connectorLogoIndex(
+  catalog: readonly ConnectorLogoSource[],
+  logoUrl: (logoAssetPath: string | null | undefined) => string | null | undefined,
+): ReadonlyMap<string, string> {
+  const logos = new Map<string, string>();
+  const entries = catalog.flatMap((item) => {
+    const url = logoUrl(item.logoAssetPath);
+    return url ? [{ item, url }] : [];
+  });
+  const claim = (domain: string | null | undefined, url: string) => {
+    if (!domain) return;
+    const key = normalizeConnectorDomain(domain);
+    if (key && !logos.has(key)) logos.set(key, url);
+  };
+  for (const { item, url } of entries) claim(item.providerDomain, url);
+  for (const { item, url } of entries) {
+    claim(item.connectionRef?.providerDomain, url);
+    claim(urlHost(item.mcpUrl), url);
+  }
+  return logos;
+}
+
+/** The logo for a connector domain from an index built by `connectorLogoIndex`. */
+export function connectorLogo(
+  index: ReadonlyMap<string, string>,
+  domain: string | null | undefined,
+): string | null {
+  return domain ? (index.get(normalizeConnectorDomain(domain)) ?? null) : null;
+}

package/src/timeline-model.ts

@@ -32,6 +32,12 @@ export {
 export type { ActivityGroup, ReadableWorkOptions, TurnGroup } from "./timeline/work-presentation";
 export { timelineGroupContainsPresentedImage } from "./timeline/presented-image";
 export { mcpToolLeaf, toolDisplayName } from "./timeline/tool-display-name";
+export {
+  connectorLogo,
+  connectorLogoIndex,
+  normalizeConnectorDomain,
+} from "./timeline/connector-logo-index";
+export type { ConnectorLogoSource } from "./timeline/connector-logo-index";
 export {
   BUILT_IN_TOOL_STEP_NAMES,
   builtInToolStep,