@@ -118,6 +118,8 @@ A streamable-HTTP server can also serve the **modern (2026-07-28) protocol era**
 
 `test-servers/configs/pagination-http.json` is the **page-by-page fetch showcase** (#1721). It serves 12 tools, 12 resources, and 12 prompts (presets `numbered_tools` / `numbered_resources` / `numbered_prompts`, `count: 12`) with `maxPageSize` of 4 for each, so every list paginates into three pages. Turn on **"Fetch Lists One Page at a Time"** (Server Settings — the `paginatedLists` setting, or the **Paginated** switch in a list sidebar) and the Tools/Resources/Prompts lists load page 1 only (4 items) with a **Load next page** control and an _N pages loaded_ status; each click fetches the next 4 and appends them, and Refresh resets to page 1. With the switch off (the default), the same lists auto-aggregate all three pages on connect.
 
+`test-servers/configs/advertised-extensions-http.json` is the **advertised-extensions showcase** (#1739). It serves `echo` (always) and a `get_weather` tool that is **gated on the `io.modelcontextprotocol/tasks` extension** (`extensionGatedTools`): the tool is registered but starts disabled, and the server enables it on `notifications/initialized` only when the connected client declared that extension in its `capabilities.extensions`. Connect (the Inspector advertises the Tasks extension by default) and the Tools list shows both `echo` and `get_weather`. Open **Server Settings → Advertised Extensions**, uncheck **Tasks (io.modelcontextprotocol/tasks)**, and reconnect: the client now advertises no extensions, the server never enables `get_weather`, and the Tools list shows only `echo`. This demonstrates the debugging knob — a server legitimately changing tool registration on what the client advertises. (Legacy stateful leg only; the modern per-request leg has no persistent `oninitialized`.)
+
 `test-servers/configs/logging-legacy-http.json` and `test-servers/configs/logging-modern-http.json` are the **logging era-fork showcase** (#1629). Both serve `logging: true` plus a `send_notification` tool that emits a `notifications/message` at a chosen level; the legacy one is a plain streamable-HTTP server (`logging/setLevel` era) and the modern one sets `transport.modern: true`. Connect to the legacy server and open the **Logs** tab to get the session-scoped **Set Active Level** selector + **Set** button; calling `send_notification` streams the log into the panel. Connect to the modern one with **Protocol Era = Modern** and the same tab instead shows the **Log Level per Request** control — pick a level to opt in and the client stamps `_meta["io.modelcontextprotocol/logLevel"]` on every subsequent request (verify in the Network tab's request body); calling `send_notification` then streams the log into the panel over the request's SSE response. Set the control back to **Off** and the same call is silently gated — the request omits the `logLevel` key, so the log never arrives. That gating is faithful to the spec ("a server MUST NOT emit `notifications/message` for a request that didn't opt in") because `send_notification` emits through the SDK's request-scoped, threshold-aware `extra.log` (`ctx.mcpReq.log`): on the modern leg it reads the per-request `logLevel` opt-in from the request envelope and drops the message when the client didn't opt in or the level is below the requested severity; on legacy it honors the session level from `logging/setLevel`. Because it emits through the request's `notify`, the modern response upgrades to SSE and the log rides the originating request's stream.
 
 `test-servers/configs/subscriptions-legacy-http.json` and `test-servers/configs/subscriptions-modern-http.json` are the **resource-subscription era-fork showcase** (#1630). Both serve three `numbered_resources` with `subscriptions: true`; the legacy one also serves an `update_resource` tool, and the modern one sets `transport.modern: true`. Connect to the **legacy** server, open a resource in the **Resources** tab and click **Subscribe** — the client sends `resources/subscribe` (Network/Protocol view) and the Subscriptions section lists the URI with no stream chrome; call `update_resource` with that URI and the server updates the content and emits `notifications/resources/updated`, stamping the subscribed tile's last-updated time. Connect to the **modern** server with **Protocol Era = Modern** and the same Subscribe instead sends **`subscriptions/listen`** (its filter carries `resourceSubscriptions` + the `resourcesListChanged` opt-in) and resolves on `notifications/subscriptions/acknowledged`; the Subscriptions section then shows the stream-status badge (`Connecting…` → `Listening`) in its header, and if the long-lived stream drops it reconnects by re-listing. The modern config deliberately **omits** `update_resource`: the SDK's modern leg is stateless/per-request (`createMcpHandler(() => createMcpServer(config))`), so the tool would run against a throwaway server instance — the content change wouldn't persist for the next `resources/read`, and its `resources/updated` wouldn't reach the (separate) listen stream — which is more confusing than useful. The live update-notification round-trip is therefore demonstrated on the legacy (stateful-session) server; the modern server is for the subscribe/listen/badge behavior. (The Inspector's _receive_ path is era-transparent, so a real stateful modern server that routes `resources/updated` onto the listen stream drives the subscribed tile the same way.)
 
@@ -2271,6 +2271,12 @@ function App() {
             savedSettings.protocolEra,
           ),
         }),
+        // Per-server advertised-extension overrides (#1739). Absent/empty falls
+        // back to the registry defaults in the InspectorClient constructor.
+        ...(savedSettings?.advertisedExtensions &&
+          Object.keys(savedSettings.advertisedExtensions).length > 0 && {
+            advertisedExtensions: savedSettings.advertisedExtensions,
+          }),
         // Set on the `/oauth/callback` rebuild so the client's `saveSession`
         // events (and any later persistence) key off the same OAuth authId
         // the pre-redirect page saved under.
 
@@ -137,6 +137,18 @@ function InteractiveRender(args: ServerSettingsFormProps) {
           settings: { ...args.settings, paginatedLists: value },
         });
       }}
+      onAdvertisedExtensionChange={(key, checked) => {
+        args.onAdvertisedExtensionChange(key, checked);
+        updateArgs({
+          settings: {
+            ...args.settings,
+            advertisedExtensions: {
+              ...args.settings.advertisedExtensions,
+              [key]: checked,
+            },
+          },
+        });
+      }}
       onMaxFetchRequestsChange={(value) => {
         args.onMaxFetchRequestsChange(value);
         updateArgs({
@@ -191,6 +203,7 @@ const meta: Meta<typeof ServerSettingsForm> = {
     onTimeoutChange: fn(),
     onAutoRefreshChange: fn(),
     onPaginatedListsChange: fn(),
+    onAdvertisedExtensionChange: fn(),
     onMaxFetchRequestsChange: fn(),
     onProtocolEraChange: fn(),
     onModernLogLevelChange: fn(),
 
@@ -66,6 +66,7 @@ const baseHandlers = {
   onTimeoutChange: vi.fn(),
   onAutoRefreshChange: vi.fn(),
   onPaginatedListsChange: vi.fn(),
+  onAdvertisedExtensionChange: vi.fn(),
   onMaxFetchRequestsChange: vi.fn(),
   onProtocolEraChange: vi.fn(),
   onModernLogLevelChange: vi.fn(),
@@ -452,6 +453,62 @@ describe("ServerSettingsForm", () => {
     expect(onAutoRefreshChange).toHaveBeenCalledWith(true);
   });
 
+  it("renders the Advertised Extensions section with Tasks checked by default", () => {
+    renderWithMantine(
+      <ServerSettingsForm
+        {...baseHandlers}
+        settings={emptySettings}
+        expandedSections={["options"]}
+      />,
+    );
+    const tasks = screen.getByRole("checkbox", {
+      name: /Tasks \(io\.modelcontextprotocol\/tasks\)/,
+    });
+    // No override present → the registry default (advertised) shows checked.
+    expect(tasks).toBeChecked();
+  });
+
+  it("reflects an advertisedExtensions override that disables Tasks", () => {
+    renderWithMantine(
+      <ServerSettingsForm
+        {...baseHandlers}
+        settings={{
+          ...emptySettings,
+          advertisedExtensions: { "io.modelcontextprotocol/tasks": false },
+        }}
+        expandedSections={["options"]}
+      />,
+    );
+    expect(
+      screen.getByRole("checkbox", {
+        name: /Tasks \(io\.modelcontextprotocol\/tasks\)/,
+      }),
+    ).not.toBeChecked();
+  });
+
+  it("invokes onAdvertisedExtensionChange when a Tasks toggle is clicked", async () => {
+    const user = userEvent.setup();
+    const onAdvertisedExtensionChange = vi.fn();
+    renderWithMantine(
+      <ServerSettingsForm
+        {...baseHandlers}
+        onAdvertisedExtensionChange={onAdvertisedExtensionChange}
+        settings={emptySettings}
+        expandedSections={["options"]}
+      />,
+    );
+    // Default is checked; clicking flips it to unadvertised.
+    await user.click(
+      screen.getByRole("checkbox", {
+        name: /Tasks \(io\.modelcontextprotocol\/tasks\)/,
+      }),
+    );
+    expect(onAdvertisedExtensionChange).toHaveBeenCalledWith(
+      "io.modelcontextprotocol/tasks",
+      false,
+    );
+  });
+
   it("renders the Network Log Size field reflecting maxFetchRequests", () => {
     renderWithMantine(
       <ServerSettingsForm
 
@@ -26,8 +26,22 @@ import {
   MODERN_LOG_LEVELS,
 } from "@inspector/core/mcp/types.js";
 import { isOAuthCapableServerType } from "@inspector/core/mcp/config.js";
+import { ADVERTISABLE_EXTENSIONS } from "@inspector/core/mcp/extensions.js";
 import type { Root } from "@modelcontextprotocol/client";
 
+/**
+ * Resolve the advertised state of an extension for the form: the per-server
+ * override wins, else the registry default. Mirrors `buildClientExtensions`'s
+ * resolution so the switches show exactly what the client will advertise.
+ */
+function isExtensionAdvertised(
+  settings: InspectorServerSettings,
+  key: string,
+  defaultAdvertised: boolean,
+): boolean {
+  return settings.advertisedExtensions?.[key] ?? defaultAdvertised;
+}
+
 export type ServerSettingsSection =
   | "options"
   | "environment"
@@ -65,6 +79,12 @@ export interface ServerSettingsFormProps {
   ) => void;
   onAutoRefreshChange: (value: boolean) => void;
   onPaginatedListsChange: (value: boolean) => void;
+  /**
+   * Toggle whether the Inspector advertises the extension `key` to this server.
+   * `checked` is the new advertise state; the modal folds it into
+   * `settings.advertisedExtensions`. (#1739)
+   */
+  onAdvertisedExtensionChange: (key: string, checked: boolean) => void;
   onMaxFetchRequestsChange: (value: number) => void;
   onProtocolEraChange: (value: ServerProtocolEra) => void;
   onModernLogLevelChange: (value: ModernLogLevel) => void;
@@ -272,6 +292,7 @@ export function ServerSettingsForm({
   onTimeoutChange,
   onAutoRefreshChange,
   onPaginatedListsChange,
+  onAdvertisedExtensionChange,
   onMaxFetchRequestsChange,
   onProtocolEraChange,
   onModernLogLevelChange,
@@ -380,6 +401,34 @@ export function ServerSettingsForm({
               checked={settings.paginatedLists ?? false}
               onChange={(e) => onPaginatedListsChange(e.currentTarget.checked)}
             />
+            <Stack gap="xs">
+              <Text size="sm" fw={500}>
+                Advertised Extensions
+              </Text>
+              <Text size="xs" c="var(--inspector-text-secondary)">
+                Which extensions the Inspector declares to this server in its
+                client capabilities. A server may register different tools
+                depending on what the client advertises — toggle these to debug
+                that. Takes effect on the next connect.
+              </Text>
+              {ADVERTISABLE_EXTENSIONS.map((ext) => (
+                <Checkbox
+                  key={ext.key}
+                  label={ext.label}
+                  checked={isExtensionAdvertised(
+                    settings,
+                    ext.key,
+                    ext.defaultAdvertised,
+                  )}
+                  onChange={(e) =>
+                    onAdvertisedExtensionChange(
+                      ext.key,
+                      e.currentTarget.checked,
+                    )
+                  }
+                />
+              ))}
+            </Stack>
             <NumberInput
               label="Network Log Size"
               description="Maximum number of HTTP requests kept in the Network log for this server. Older entries rotate out past this limit; a response body that arrives after its entry rotated out is dropped. Use 0 for unlimited (not recommended). Applies immediately to the active connection."
 
@@ -162,6 +162,63 @@ describe("ServerSettingsModal", () => {
     );
   });
 
+  it("folds an advertised-extension toggle into settings.advertisedExtensions (#1739)", async () => {
+    const user = userEvent.setup();
+    const onSettingsChange = vi.fn();
+    renderWithMantine(
+      <ServerSettingsModal
+        opened
+        settings={emptySettings}
+        serverType="streamable-http"
+        isStdio={false}
+        onClose={vi.fn()}
+        onSettingsChange={onSettingsChange}
+      />,
+    );
+    // The Options section is expanded by default; Tasks is checked (registry
+    // default), so clicking it toggles the override off.
+    await user.click(
+      screen.getByRole("checkbox", {
+        name: /Tasks \(io\.modelcontextprotocol\/tasks\)/,
+      }),
+    );
+    expect(onSettingsChange).toHaveBeenCalledWith(
+      expect.objectContaining({
+        advertisedExtensions: { "io.modelcontextprotocol/tasks": false },
+      }),
+    );
+  });
+
+  it("reconverges to no override when an extension toggle returns to its default (#1739)", async () => {
+    const user = userEvent.setup();
+    const onSettingsChange = vi.fn();
+    renderWithMantine(
+      <ServerSettingsModal
+        opened
+        // Start from a disabling override so re-checking Tasks returns it to the
+        // registry default (advertised) and should drop the key entirely.
+        settings={{
+          ...emptySettings,
+          advertisedExtensions: { "io.modelcontextprotocol/tasks": false },
+        }}
+        serverType="streamable-http"
+        isStdio={false}
+        onClose={vi.fn()}
+        onSettingsChange={onSettingsChange}
+      />,
+    );
+    await user.click(
+      screen.getByRole("checkbox", {
+        name: /Tasks \(io\.modelcontextprotocol\/tasks\)/,
+      }),
+    );
+    // The only override returned to its default → the whole map drops to
+    // undefined (no-override), keeping the on-disk round-trip minimal.
+    expect(onSettingsChange).toHaveBeenCalledWith(
+      expect.objectContaining({ advertisedExtensions: undefined }),
+    );
+  });
+
   it("hides the modern log-level control when this server negotiated legacy under 'auto' (#1629)", () => {
     renderWithMantine(
       <ServerSettingsModal
 
@@ -9,6 +9,7 @@ import type {
   ServerType,
 } from "@inspector/core/mcp/types.js";
 import { isOAuthCapableServerType } from "@inspector/core/mcp/config.js";
+import { ADVERTISABLE_EXTENSIONS } from "@inspector/core/mcp/extensions.js";
 import { ListToggle } from "../../elements/ListToggle/ListToggle";
 import {
   ServerSettingsForm,
@@ -176,6 +177,24 @@ export function ServerSettingsModal({
     onSettingsChange({ ...settings, paginatedLists: value });
   }
 
+  function handleAdvertisedExtensionChange(key: string, checked: boolean) {
+    const next = { ...settings.advertisedExtensions };
+    const ext = ADVERTISABLE_EXTENSIONS.find((e) => e.key === key);
+    // Reconverge to "no override" when the toggle returns to the registry
+    // default, so the on-disk map (and its byte-stable round-trip) stays minimal
+    // — matching the omit-when-default policy used for the other settings. Only
+    // a value that actually differs from the default is persisted.
+    if (ext && checked === ext.defaultAdvertised) {
+      delete next[key];
+    } else {
+      next[key] = checked;
+    }
+    onSettingsChange({
+      ...settings,
+      advertisedExtensions: Object.keys(next).length > 0 ? next : undefined,
+    });
+  }
+
   function handleMaxFetchRequestsChange(value: number) {
     onSettingsChange({ ...settings, maxFetchRequests: value });
   }
@@ -251,6 +270,7 @@ export function ServerSettingsModal({
           onTimeoutChange={handleTimeoutChange}
           onAutoRefreshChange={handleAutoRefreshChange}
           onPaginatedListsChange={handlePaginatedListsChange}
+          onAdvertisedExtensionChange={handleAdvertisedExtensionChange}
           onMaxFetchRequestsChange={handleMaxFetchRequestsChange}
           onProtocolEraChange={handleProtocolEraChange}
           onModernLogLevelChange={handleModernLogLevelChange}
 
@@ -284,6 +284,63 @@ describe("serverEntriesToMcpConfig", () => {
     expect(round).toEqual(original);
   });
 
+  it("round-trips advertisedExtensions: lifts a non-empty map to settings and back to disk", () => {
+    const original: MCPConfig = {
+      mcpServers: {
+        exttest: {
+          type: "streamable-http",
+          url: "https://x.test/mcp",
+          advertisedExtensions: { "io.modelcontextprotocol/tasks": false },
+        },
+      },
+    };
+    const [entry] = mcpConfigToServerEntries(original);
+    expect(entry?.settings?.advertisedExtensions).toEqual({
+      "io.modelcontextprotocol/tasks": false,
+    });
+    const round = serverEntriesToMcpConfig(mcpConfigToServerEntries(original));
+    expect(round).toEqual(original);
+  });
+
+  it("omits advertisedExtensions from disk when unset, and leaves settings unset", () => {
+    const original: MCPConfig = {
+      mcpServers: {
+        extnone: {
+          type: "streamable-http",
+          url: "https://x.test/mcp",
+          connectionTimeout: 5000,
+        },
+      },
+    };
+    const [entry] = mcpConfigToServerEntries(original);
+    expect(entry?.settings?.advertisedExtensions).toBeUndefined();
+    const round = serverEntriesToMcpConfig(mcpConfigToServerEntries(original));
+    expect("advertisedExtensions" in (round.mcpServers.extnone ?? {})).toBe(
+      false,
+    );
+    expect(round).toEqual(original);
+  });
+
+  it("treats an empty advertisedExtensions map on disk as unset (omitted on write)", () => {
+    const original: MCPConfig = {
+      mcpServers: {
+        extempty: {
+          type: "streamable-http",
+          url: "https://x.test/mcp",
+          advertisedExtensions: {},
+        },
+      },
+    };
+    const [entry] = mcpConfigToServerEntries(original);
+    // An empty map reads back as unset for the form...
+    expect(entry?.settings?.advertisedExtensions).toBeUndefined();
+    // ...and the write side omits it, so the empty map does not round-trip.
+    const round = serverEntriesToMcpConfig(mcpConfigToServerEntries(original));
+    expect("advertisedExtensions" in (round.mcpServers.extempty ?? {})).toBe(
+      false,
+    );
+  });
+
   it("round-trips maxFetchRequests: lifts a non-default value to settings and back to disk", () => {
     const original: MCPConfig = {
       mcpServers: {