From 56a3c8012bade906db56c98db5336b4b5d3fa1f3 Mon Sep 17 00:00:00 2001
From: Jason Madigan <jason@jasonmadigan.com>
Date: Mon, 17 Aug 2026 11:56:05 +0100
Subject: [PATCH 1/4] feat: add throwaway MCP inspector page (PoC)

proves the direct browser-to-gateway design: watch MCPGatewayExtension
resources, speak MCP Streamable HTTP directly to status.mcpEndpoint, and
render tools/list + tools/call. dependency-free json-rpc client handling
json + sse responses; session id and token kept in react state only.

Refs #671

Signed-off-by: Jason Madigan <jason@jasonmadigan.com>
---
 console-extensions.json                       |   8 +
 .../en/plugin__kuadrant-console-plugin.json   |  31 +-
 package.json                                  |   3 +-
 src/components/mcp/MCPInspectorPage.tsx       | 330 ++++++++++++++++++
 src/components/mcp/types.ts                   |   1 +
 src/utils/mcp/client.ts                       | 218 ++++++++++++
 6 files changed, 588 insertions(+), 3 deletions(-)
 create mode 100644 src/components/mcp/MCPInspectorPage.tsx
 create mode 100644 src/utils/mcp/client.ts

diff --git a/console-extensions.json b/console-extensions.json
index 79318263..05ce9bcf 100644
--- a/console-extensions.json
+++ b/console-extensions.json
@@ -701,5 +701,13 @@
       "path": "/kuadrant/mcp/setup-wizard",
       "component": { "$codeRef": "MCPSetupWizard" }
     }
+  },
+  {
+    "type": "console.page/route",
+    "properties": {
+      "exact": true,
+      "path": "/mcp-inspector",
+      "component": { "$codeRef": "MCPInspectorPage" }
+    }
   }
 ]
diff --git a/locales/en/plugin__kuadrant-console-plugin.json b/locales/en/plugin__kuadrant-console-plugin.json
index 3da8d99c..7277e557 100644
--- a/locales/en/plugin__kuadrant-console-plugin.json
+++ b/locales/en/plugin__kuadrant-console-plugin.json
@@ -845,5 +845,32 @@
   "You do not have permission to view Policies": "You do not have permission to view Policies",
   "You do not have permission to view Policy Topology": "You do not have permission to view Policy Topology",
   "You do not have permission to view Reference grants": "You do not have permission to view Reference grants",
-  "You do not have permission to view this resource": "You do not have permission to view this resource"
-}
\ No newline at end of file
+  "You do not have permission to view this resource": "You do not have permission to view this resource",
+  "MCP Inspector": "MCP Inspector",
+  "Throwaway proof-of-concept: the browser speaks MCP Streamable HTTP directly to a gateway endpoint. Calls are cross-origin.": "Throwaway proof-of-concept: the browser speaks MCP Streamable HTTP directly to a gateway endpoint. Calls are cross-origin.",
+  "Browser origin": "Browser origin",
+  "MCP gateway extension": "MCP gateway extension",
+  "Select an MCP gateway extension": "Select an MCP gateway extension",
+  "Loading extensions...": "Loading extensions...",
+  "Select an extension...": "Select an extension...",
+  "not reachable": "not reachable",
+  "Resolved endpoint": "Resolved endpoint",
+  "none": "none",
+  "Bearer token (optional)": "Bearer token (optional)",
+  "Held in memory only": "Held in memory only",
+  "Connect + list tools": "Connect + list tools",
+  "Session ID": "Session ID",
+  "Session expired, reconnect": "Session expired, reconnect",
+  "The MCP session is no longer valid. Connect again to start a new session.": "The MCP session is no longer valid. Connect again to start a new session.",
+  "initialize": "initialize",
+  "tools/list": "tools/list",
+  "Call a tool": "Call a tool",
+  "Tool": "Tool",
+  "Select a tool": "Select a tool",
+  "Select a tool...": "Select a tool...",
+  "Arguments (JSON)": "Arguments (JSON)",
+  "Tool call arguments as JSON": "Tool call arguments as JSON",
+  "Call": "Call",
+  "tools/call result": "tools/call result",
+  "Arguments must be valid JSON": "Arguments must be valid JSON"
+}
diff --git a/package.json b/package.json
index febc765f..2d25ed7d 100644
--- a/package.json
+++ b/package.json
@@ -123,7 +123,8 @@
       "GatewaySingleOverview": "./components/gateway/GatewaySingleOverview",
       "HTTPRouteSingleOverview": "./components/httproute/HTTPRouteSingleOverview",
       "MCPOverviewPage": "./components/mcp/MCPOverviewPage",
-      "MCPSetupWizard": "./components/mcp/MCPSetupWizard"
+      "MCPSetupWizard": "./components/mcp/MCPSetupWizard",
+      "MCPInspectorPage": "./components/mcp/MCPInspectorPage"
     },
     "dependencies": {
       "@console/pluginAPI": ">=4.22.0-0"
diff --git a/src/components/mcp/MCPInspectorPage.tsx b/src/components/mcp/MCPInspectorPage.tsx
new file mode 100644
index 00000000..4b9d713f
--- /dev/null
+++ b/src/components/mcp/MCPInspectorPage.tsx
@@ -0,0 +1,330 @@
+import * as React from 'react';
+import Helmet from 'react-helmet';
+import { useTranslation } from 'react-i18next';
+import {
+  PageSection,
+  Title,
+  Content,
+  Form,
+  FormGroup,
+  FormSelect,
+  FormSelectOption,
+  TextInput,
+  TextArea,
+  Button,
+  Alert,
+  Stack,
+  StackItem,
+  Divider,
+} from '@patternfly/react-core';
+import {
+  NamespaceBar,
+  useActiveNamespace,
+  useK8sWatchResource,
+} from '@openshift-console/dynamic-plugin-sdk';
+import { RESOURCES } from '../../utils/resources';
+import { MCPGatewayExtension } from './types';
+import {
+  MCPClient,
+  MCPSessionExpiredError,
+  MCPTool,
+  InitializeResult,
+  ToolsListResult,
+  ToolsCallResult,
+} from '../../utils/mcp/client';
+
+const ALL_NS = '#ALL_NS#';
+
+const preStyle: React.CSSProperties = {
+  whiteSpace: 'pre-wrap',
+  wordBreak: 'break-word',
+  overflow: 'auto',
+  maxHeight: '20rem',
+  padding: 'var(--pf-t--global--spacer--md, 1rem)',
+  background: 'var(--pf-t--global--background--color--secondary--default, #f5f5f5)',
+  borderRadius: 'var(--pf-t--global--border--radius--small, 4px)',
+};
+
+const isReady = (ext: MCPGatewayExtension): boolean =>
+  (ext.status?.conditions ?? []).some((c) => c.type === 'Ready' && c.status === 'True');
+
+const extKey = (ext: MCPGatewayExtension): string =>
+  `${ext.metadata?.namespace}/${ext.metadata?.name}`;
+
+const MCPInspectorPage: React.FC = () => {
+  const { t } = useTranslation('plugin__kuadrant-console-plugin');
+  const [activeNamespace] = useActiveNamespace();
+  const resolvedNamespace = activeNamespace === ALL_NS ? undefined : activeNamespace;
+
+  const [extensions, extensionsLoaded] = useK8sWatchResource<MCPGatewayExtension[]>({
+    groupVersionKind: RESOURCES.MCPGatewayExtension.gvk,
+    isList: true,
+    namespace: resolvedNamespace,
+  });
+
+  const [selectedKey, setSelectedKey] = React.useState('');
+  const [token, setToken] = React.useState('');
+
+  // session id lives in react state and on the client instance only, never localStorage.
+  const clientRef = React.useRef<MCPClient | null>(null);
+  const [sessionId, setSessionId] = React.useState<string | null>(null);
+
+  const [initResult, setInitResult] = React.useState<InitializeResult | null>(null);
+  const [toolsResult, setToolsResult] = React.useState<ToolsListResult | null>(null);
+  const [tools, setTools] = React.useState<MCPTool[]>([]);
+
+  const [selectedTool, setSelectedTool] = React.useState('');
+  const [argsText, setArgsText] = React.useState('{}');
+  const [callResult, setCallResult] = React.useState<ToolsCallResult | null>(null);
+
+  const [connecting, setConnecting] = React.useState(false);
+  const [calling, setCalling] = React.useState(false);
+  const [error, setError] = React.useState('');
+  const [sessionExpired, setSessionExpired] = React.useState(false);
+
+  const list = React.useMemo(() => extensions ?? [], [extensions]);
+  const selected = React.useMemo(
+    () => list.find((ext) => extKey(ext) === selectedKey),
+    [list, selectedKey],
+  );
+  const endpoint = selected?.status?.mcpEndpoint ?? '';
+  const origin = window.location.origin;
+
+  const handleConnect = async () => {
+    if (!endpoint) {
+      return;
+    }
+    setError('');
+    setSessionExpired(false);
+    setConnecting(true);
+    setInitResult(null);
+    setToolsResult(null);
+    setTools([]);
+    setSelectedTool('');
+    setCallResult(null);
+    try {
+      const client = new MCPClient(endpoint, { token: token || undefined });
+      const { result, sessionId: id } = await client.initialize();
+      await client.sendInitialized();
+      const listed = await client.toolsList();
+      clientRef.current = client;
+      setSessionId(id);
+      setInitResult(result);
+      setToolsResult(listed);
+      setTools(listed.tools ?? []);
+    } catch (err) {
+      clientRef.current = null;
+      setSessionId(null);
+      setError(err instanceof Error ? err.message : String(err));
+    } finally {
+      setConnecting(false);
+    }
+  };
+
+  const handleCall = async () => {
+    const client = clientRef.current;
+    if (!client || !selectedTool) {
+      return;
+    }
+    let parsedArgs: Record<string, unknown>;
+    try {
+      parsedArgs = argsText.trim() === '' ? {} : JSON.parse(argsText);
+    } catch {
+      setError(t('Arguments must be valid JSON'));
+      return;
+    }
+    setError('');
+    setSessionExpired(false);
+    setCalling(true);
+    setCallResult(null);
+    try {
+      const result = await client.toolsCall(selectedTool, parsedArgs);
+      setCallResult(result);
+    } catch (err) {
+      if (err instanceof MCPSessionExpiredError) {
+        setSessionExpired(true);
+      } else {
+        setError(err instanceof Error ? err.message : String(err));
+      }
+    } finally {
+      setCalling(false);
+    }
+  };
+
+  return (
+    <>
+      <Helmet>
+        <title>{t('MCP Inspector')}</title>
+      </Helmet>
+      <NamespaceBar />
+      <PageSection>
+        <Stack hasGutter>
+          <StackItem>
+            <Title headingLevel="h1">{t('MCP Inspector')}</Title>
+            <Content component="p">
+              {t(
+                'Throwaway proof-of-concept: the browser speaks MCP Streamable HTTP directly to a gateway endpoint. Calls are cross-origin.',
+              )}
+            </Content>
+            <Content component="small">
+              {t('Browser origin')}: <code>{origin}</code>
+            </Content>
+          </StackItem>
+
+          <StackItem>
+            <Form>
+              <FormGroup label={t('MCP gateway extension')} fieldId="mcp-inspector-extension">
+                <FormSelect
+                  id="mcp-inspector-extension"
+                  value={selectedKey}
+                  onChange={(_event, value) => setSelectedKey(value)}
+                  aria-label={t('Select an MCP gateway extension')}
+                  isDisabled={!extensionsLoaded}
+                >
+                  <FormSelectOption
+                    value=""
+                    label={
+                      !extensionsLoaded ? t('Loading extensions...') : t('Select an extension...')
+                    }
+                    isPlaceholder
+                  />
+                  {list.map((ext) => {
+                    const reachable = !!ext.status?.mcpEndpoint && isReady(ext);
+                    const name = `${ext.metadata?.name} (${ext.metadata?.namespace})`;
+                    return (
+                      <FormSelectOption
+                        key={extKey(ext)}
+                        value={extKey(ext)}
+                        label={reachable ? name : `${name} — ${t('not reachable')}`}
+                        isDisabled={!reachable}
+                      />
+                    );
+                  })}
+                </FormSelect>
+              </FormGroup>
+
+              <FormGroup label={t('Resolved endpoint')} fieldId="mcp-inspector-endpoint">
+                <Content component="small">
+                  <code>{endpoint || t('none')}</code>
+                </Content>
+              </FormGroup>
+
+              <FormGroup label={t('Bearer token (optional)')} fieldId="mcp-inspector-token">
+                <TextInput
+                  id="mcp-inspector-token"
+                  type="password"
+                  value={token}
+                  onChange={(_event, value) => setToken(value)}
+                  placeholder={t('Held in memory only')}
+                />
+              </FormGroup>
+
+              <StackItem>
+                <Button
+                  variant="primary"
+                  onClick={handleConnect}
+                  isDisabled={!endpoint || connecting}
+                  isLoading={connecting}
+                >
+                  {t('Connect + list tools')}
+                </Button>
+              </StackItem>
+            </Form>
+          </StackItem>
+
+          {sessionId && (
+            <StackItem>
+              <Content component="small">
+                {t('Session ID')}: <code>{sessionId}</code>
+              </Content>
+            </StackItem>
+          )}
+
+          {error && (
+            <StackItem>
+              <Alert variant="danger" isInline title={t('Request failed')}>
+                {error}
+              </Alert>
+            </StackItem>
+          )}
+
+          {sessionExpired && (
+            <StackItem>
+              <Alert variant="warning" isInline title={t('Session expired, reconnect')}>
+                {t('The MCP session is no longer valid. Connect again to start a new session.')}
+              </Alert>
+            </StackItem>
+          )}
+
+          {initResult && (
+            <StackItem>
+              <Title headingLevel="h2">{t('initialize')}</Title>
+              <pre style={preStyle}>{JSON.stringify(initResult, null, 2)}</pre>
+            </StackItem>
+          )}
+
+          {toolsResult && (
+            <StackItem>
+              <Title headingLevel="h2">{t('tools/list')}</Title>
+              <pre style={preStyle}>{JSON.stringify(toolsResult, null, 2)}</pre>
+            </StackItem>
+          )}
+
+          {tools.length > 0 && (
+            <>
+              <StackItem>
+                <Divider />
+              </StackItem>
+              <StackItem>
+                <Title headingLevel="h2">{t('Call a tool')}</Title>
+                <Form>
+                  <FormGroup label={t('Tool')} fieldId="mcp-inspector-tool">
+                    <FormSelect
+                      id="mcp-inspector-tool"
+                      value={selectedTool}
+                      onChange={(_event, value) => setSelectedTool(value)}
+                      aria-label={t('Select a tool')}
+                    >
+                      <FormSelectOption value="" label={t('Select a tool...')} isPlaceholder />
+                      {tools.map((tool) => (
+                        <FormSelectOption key={tool.name} value={tool.name} label={tool.name} />
+                      ))}
+                    </FormSelect>
+                  </FormGroup>
+                  <FormGroup label={t('Arguments (JSON)')} fieldId="mcp-inspector-args">
+                    <TextArea
+                      id="mcp-inspector-args"
+                      value={argsText}
+                      onChange={(_event, value) => setArgsText(value)}
+                      rows={6}
+                      aria-label={t('Tool call arguments as JSON')}
+                    />
+                  </FormGroup>
+                  <StackItem>
+                    <Button
+                      variant="secondary"
+                      onClick={handleCall}
+                      isDisabled={!selectedTool || calling}
+                      isLoading={calling}
+                    >
+                      {t('Call')}
+                    </Button>
+                  </StackItem>
+                </Form>
+              </StackItem>
+            </>
+          )}
+
+          {callResult && (
+            <StackItem>
+              <Title headingLevel="h2">{t('tools/call result')}</Title>
+              <pre style={preStyle}>{JSON.stringify(callResult, null, 2)}</pre>
+            </StackItem>
+          )}
+        </Stack>
+      </PageSection>
+    </>
+  );
+};
+
+export default MCPInspectorPage;
diff --git a/src/components/mcp/types.ts b/src/components/mcp/types.ts
index bc11989b..e54c2234 100644
--- a/src/components/mcp/types.ts
+++ b/src/components/mcp/types.ts
@@ -39,6 +39,7 @@ export interface MCPGatewayExtension extends K8sResourceCommon {
   };
   status?: {
     conditions?: Condition[];
+    mcpEndpoint?: string;
   };
 }
 
diff --git a/src/utils/mcp/client.ts b/src/utils/mcp/client.ts
new file mode 100644
index 00000000..2d7ede60
--- /dev/null
+++ b/src/utils/mcp/client.ts
@@ -0,0 +1,218 @@
+// tiny dependency-free mcp streamable http client (poc).
+// speaks json-rpc 2.0 over a single endpoint, handles json + sse responses,
+// and keeps the session id in memory only (caller holds it in react state).
+
+const MCP_PROTOCOL_VERSION = '2025-03-26';
+
+export interface JsonRpcError {
+  code: number;
+  message: string;
+  data?: unknown;
+}
+
+interface JsonRpcResponse<T> {
+  jsonrpc: '2.0';
+  id: number | string | null;
+  result?: T;
+  error?: JsonRpcError;
+}
+
+export interface InitializeResult {
+  protocolVersion: string;
+  capabilities?: Record<string, unknown>;
+  serverInfo?: { name?: string; version?: string };
+  instructions?: string;
+  [key: string]: unknown;
+}
+
+export interface MCPTool {
+  name: string;
+  description?: string;
+  inputSchema?: Record<string, unknown>;
+  [key: string]: unknown;
+}
+
+export interface ToolsListResult {
+  tools: MCPTool[];
+  nextCursor?: string;
+  [key: string]: unknown;
+}
+
+export interface ToolsCallResult {
+  content?: Array<{ type: string; text?: string; [key: string]: unknown }>;
+  isError?: boolean;
+  [key: string]: unknown;
+}
+
+// json-rpc level error (server returned an error object).
+export class MCPRpcError extends Error {
+  code: number;
+  data?: unknown;
+  constructor(err: JsonRpcError) {
+    super(err.message);
+    this.name = 'MCPRpcError';
+    this.code = err.code;
+    this.data = err.data;
+  }
+}
+
+// transport error (non-2xx that is not a 404 session expiry).
+export class MCPHttpError extends Error {
+  status: number;
+  constructor(status: number, message: string) {
+    super(message);
+    this.name = 'MCPHttpError';
+    this.status = status;
+  }
+}
+
+// distinct so the page can prompt "session expired, reconnect".
+export class MCPSessionExpiredError extends Error {
+  constructor() {
+    super('session expired');
+    this.name = 'MCPSessionExpiredError';
+  }
+}
+
+export interface MCPClientOptions {
+  token?: string;
+}
+
+export class MCPClient {
+  private readonly endpoint: string;
+  private token?: string;
+  private sessionId: string | null = null;
+  private nextId = 1;
+
+  constructor(endpoint: string, options: MCPClientOptions = {}) {
+    this.endpoint = endpoint;
+    this.token = options.token;
+  }
+
+  getSessionId(): string | null {
+    return this.sessionId;
+  }
+
+  // initialize handshake. captures Mcp-Session-Id off the response headers.
+  async initialize(): Promise<{ result: InitializeResult; sessionId: string | null }> {
+    const res = await this.post({
+      jsonrpc: '2.0',
+      id: this.nextId++,
+      method: 'initialize',
+      params: {
+        protocolVersion: MCP_PROTOCOL_VERSION,
+        capabilities: {},
+        clientInfo: { name: 'kuadrant-mcp-inspector', version: '0.0.0' },
+      },
+    });
+    if (!res.ok) {
+      throw new MCPHttpError(res.status, `initialize failed (http ${res.status})`);
+    }
+    const headerSession = res.headers.get('Mcp-Session-Id');
+    if (headerSession) {
+      this.sessionId = headerSession;
+    }
+    const message = await parseRpcMessage<InitializeResult>(res);
+    throwOnRpcError(message);
+    return { result: message.result as InitializeResult, sessionId: this.sessionId };
+  }
+
+  // notifications/initialized: a notification (no id), server replies 202 with no body.
+  async sendInitialized(): Promise<void> {
+    const res = await this.post({ jsonrpc: '2.0', method: 'notifications/initialized' });
+    if (!res.ok) {
+      throw this.httpErrorFor(res.status, 'notifications/initialized failed');
+    }
+  }
+
+  async toolsList(): Promise<ToolsListResult> {
+    return this.call<ToolsListResult>('tools/list', {});
+  }
+
+  async toolsCall(name: string, args: Record<string, unknown>): Promise<ToolsCallResult> {
+    return this.call<ToolsCallResult>('tools/call', { name, arguments: args });
+  }
+
+  private async call<T>(method: string, params: Record<string, unknown>): Promise<T> {
+    const res = await this.post({ jsonrpc: '2.0', id: this.nextId++, method, params });
+    if (!res.ok) {
+      throw this.httpErrorFor(res.status, `${method} failed`);
+    }
+    const message = await parseRpcMessage<T>(res);
+    throwOnRpcError(message);
+    return message.result as T;
+  }
+
+  // 404 on a session-scoped call means the session expired.
+  private httpErrorFor(status: number, context: string): Error {
+    if (status === 404 && this.sessionId) {
+      return new MCPSessionExpiredError();
+    }
+    return new MCPHttpError(status, `${context} (http ${status})`);
+  }
+
+  private post(body: Record<string, unknown>): Promise<Response> {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+      Accept: 'application/json, text/event-stream',
+      'MCP-Protocol-Version': MCP_PROTOCOL_VERSION,
+    };
+    if (this.sessionId) {
+      headers['Mcp-Session-Id'] = this.sessionId;
+    }
+    if (this.token) {
+      headers.Authorization = `Bearer ${this.token}`;
+    }
+    return fetch(this.endpoint, {
+      method: 'POST',
+      credentials: 'omit',
+      headers,
+      body: JSON.stringify(body),
+    });
+  }
+}
+
+function throwOnRpcError(message: JsonRpcResponse<unknown>): void {
+  if (message.error) {
+    throw new MCPRpcError(message.error);
+  }
+}
+
+// responses are either application/json or an sse stream carrying the
+// json-rpc message in `data:` lines. buffer the body and extract the message.
+async function parseRpcMessage<T>(res: Response): Promise<JsonRpcResponse<T>> {
+  const contentType = res.headers.get('Content-Type') || '';
+  const text = await res.text();
+  if (contentType.includes('text/event-stream')) {
+    const message = extractSseRpcMessage<T>(text);
+    if (!message) {
+      throw new MCPHttpError(res.status, 'no json-rpc message in event stream');
+    }
+    return message;
+  }
+  return JSON.parse(text) as JsonRpcResponse<T>;
+}
+
+// walk sse events, return the first `data:` payload that parses to a
+// json-rpc response envelope.
+function extractSseRpcMessage<T>(raw: string): JsonRpcResponse<T> | null {
+  const events = raw.split(/\r?\n\r?\n/);
+  for (const event of events) {
+    const dataLines = event
+      .split(/\r?\n/)
+      .filter((line) => line.startsWith('data:'))
+      .map((line) => line.slice(5).trim());
+    if (dataLines.length === 0) {
+      continue;
+    }
+    try {
+      const parsed = JSON.parse(dataLines.join('\n')) as JsonRpcResponse<T>;
+      if (parsed && parsed.jsonrpc === '2.0') {
+        return parsed;
+      }
+    } catch {
+      // not json, try next event
+    }
+  }
+  return null;
+}

From f9a1fcb25d71bae35f5dcfb75d9a06f1c0056bcb Mon Sep 17 00:00:00 2001
From: Jason Madigan <jason@jasonmadigan.com>
Date: Tue, 25 Aug 2026 09:12:51 +0100
Subject: [PATCH 2/4] feat: complete MCP inspector workflow

Add direct MCP tool discovery and execution with schema-driven inputs, refresh, request output, bearer-token authentication, and OIDC PKCE support.

Avoid PatternFly Content margins in the request summary so HTTP status and duration remain aligned. Document CORS and Console CSP deployment requirements.
---
 build/suite-router.sh                         |   2 +-
 console-extensions.json                       |  20 +
 docs/mcp-inspector.md                         |  60 ++
 docs/overview.md                              |  11 +-
 e2e/tests/mcp-inspector.spec.ts               |  66 ++
 .../en/plugin__kuadrant-console-plugin.json   |  72 ++-
 src/components/mcp/MCPInspectorOutput.tsx     |  82 +++
 src/components/mcp/MCPInspectorPage.css       | 194 ++++++
 src/components/mcp/MCPInspectorPage.test.tsx  | 254 ++++++++
 src/components/mcp/MCPInspectorPage.tsx       | 591 ++++++++++++------
 src/components/mcp/MCPToolWorkspace.tsx       | 450 +++++++++++++
 src/utils/mcp/client.test.ts                  |  73 +++
 src/utils/mcp/client.ts                       |  83 ++-
 src/utils/mcp/oauth.test.ts                   | 144 +++++
 src/utils/mcp/oauth.ts                        | 301 +++++++++
 15 files changed, 2194 insertions(+), 209 deletions(-)
 create mode 100644 docs/mcp-inspector.md
 create mode 100644 e2e/tests/mcp-inspector.spec.ts
 create mode 100644 src/components/mcp/MCPInspectorOutput.tsx
 create mode 100644 src/components/mcp/MCPInspectorPage.css
 create mode 100644 src/components/mcp/MCPInspectorPage.test.tsx
 create mode 100644 src/components/mcp/MCPToolWorkspace.tsx
 create mode 100644 src/utils/mcp/client.test.ts
 create mode 100644 src/utils/mcp/oauth.test.ts
 create mode 100644 src/utils/mcp/oauth.ts

diff --git a/build/suite-router.sh b/build/suite-router.sh
index 314250a7..0a086d20 100755
--- a/build/suite-router.sh
+++ b/build/suite-router.sh
@@ -102,7 +102,7 @@ if echo "$CHANGED" | grep -qE "^src/components/(AttachedResources|gateway/Gatewa
 fi
 
 if echo "$CHANGED" | grep -qE "^src/components/mcp/"; then
-  SPECS="$SPECS mcp-setup-wizard.spec.ts mcp-overview.spec.ts"
+  SPECS="$SPECS mcp-setup-wizard.spec.ts mcp-overview.spec.ts mcp-inspector.spec.ts"
 fi
 
 # Detect test files that changed → run all tags (smoke + nightly) for those files only
diff --git a/console-extensions.json b/console-extensions.json
index 05ce9bcf..267096cf 100644
--- a/console-extensions.json
+++ b/console-extensions.json
@@ -659,6 +659,16 @@
       "section": "kuadrant-mcp-section-admin"
     }
   },
+  {
+    "type": "console.navigation/href",
+    "properties": {
+      "id": "kuadrant-mcp-inspector-admin",
+      "name": "%plugin__kuadrant-console-plugin~MCP Inspector%",
+      "href": "/mcp-inspector",
+      "perspective": "admin",
+      "section": "kuadrant-mcp-section-admin"
+    }
+  },
   {
     "type": "console.navigation/section",
     "properties": {
@@ -678,6 +688,16 @@
       "section": "kuadrant-mcp-section-dev"
     }
   },
+  {
+    "type": "console.navigation/href",
+    "properties": {
+      "id": "kuadrant-mcp-inspector-dev",
+      "name": "%plugin__kuadrant-console-plugin~MCP Inspector%",
+      "href": "/mcp-inspector",
+      "perspective": "dev",
+      "section": "kuadrant-mcp-section-dev"
+    }
+  },
   {
     "type": "console.page/route",
     "properties": {
diff --git a/docs/mcp-inspector.md b/docs/mcp-inspector.md
new file mode 100644
index 00000000..83421246
--- /dev/null
+++ b/docs/mcp-inspector.md
@@ -0,0 +1,60 @@
+# MCP Inspector
+
+The MCP Inspector lets an OpenShift Console user inspect and run tools exposed by an MCP Gateway. The browser connects directly to the endpoint reported in `MCPGatewayExtension.status.mcpEndpoint`; the console plugin does not proxy MCP traffic.
+
+## Prerequisites
+
+- The `MCPGatewayExtension` must have a `Ready=True` condition and a non-empty `status.mcpEndpoint`.
+- The gateway must allow the OpenShift Console origin through CORS, including the MCP protocol and session headers used by Streamable HTTP.
+- The plugin's `ConsolePlugin.spec.contentSecurityPolicy` must allow the MCP and OIDC origins with the `ConnectSrc` directive when Console CSP is enabled.
+- Production gateways should require authentication. An unauthenticated gateway reachable from a user's browser can be called by malicious websites if its CORS policy permits their origins.
+
+## Content Security Policy
+
+OpenShift Console reports a `connect-src` violation when the inspector connects to an origin that is not listed by an enabled `ConsolePlugin`. Current Console releases report these violations without blocking the request, but the required origins should still be declared so the inspector continues to work when CSP is enforced.
+
+Add every MCP gateway origin and every OIDC origin used for discovery, client registration, or token exchange to the plugin resource. For example:
+
+```yaml
+spec:
+  contentSecurityPolicy:
+    - directive: ConnectSrc
+      values:
+        - https://mcp.example.com
+        - https://sso.example.com
+```
+
+Console does not permit `*` as a CSP value, so deployments with gateway endpoints on different origins must maintain this allowlist as gateways are added or removed. The development Console accepts the equivalent bridge setting, for example `BRIDGE_CONTENT_SECURITY_POLICY="connect-src=ws://localhost:9001 http://mcp.127-0-0-1.sslip.io:8080"`.
+
+## Authentication
+
+The inspector first attempts an unauthenticated MCP `initialize` request. If the gateway returns a `401` challenge, the user can:
+
+- sign in with OIDC using authorization-server discovery, dynamic client registration, authorization code, and PKCE; or
+- paste a bearer token that is sent as an `Authorization: Bearer` header.
+
+Access tokens and MCP session IDs are held in memory only. Temporary PKCE callback state is held in `sessionStorage` and removed after the callback. Requests use `credentials: omit`; browser cookies are not sent to the MCP endpoint.
+
+## Using the inspector
+
+1. Open **MCP management → MCP Inspector**.
+2. Select a Ready MCP gateway extension. The inspector initializes a session and lists its tools.
+3. Select or search for a tool. Use the **Refresh tools** icon to run `tools/list` again without reconnecting the session.
+4. Fill the schema-generated inputs. Complex object and array inputs accept JSON.
+5. Optionally add MCP `_meta` key-value pairs.
+6. Use **Validate only** to check the input locally, or **Run tool** to execute it.
+7. Inspect the server result, JSON-RPC request and response, HTTP status, and elapsed time in the Output card.
+
+Changing gateways clears the current token, MCP session, selected tool, output, and session statistics.
+
+## Live Playwright journey
+
+The standard smoke test verifies that the inspector opens in Console. A live tool-call journey is available when a Ready development gateway is present:
+
+```bash
+MCP_INSPECTOR_E2E_EXTENSION=mcp-gateway-system/mcp-gateway-extension \
+  npx playwright test --config=e2e/playwright.config.ts \
+  e2e/tests/mcp-inspector.spec.ts -g "connects to a live gateway"
+```
+
+The journey defaults to `toystore_greet` with `Name=Ada`. Override `MCP_INSPECTOR_E2E_TOOL`, `MCP_INSPECTOR_E2E_ARGUMENT_LABEL`, and `MCP_INSPECTOR_E2E_ARGUMENT_VALUE` for another development server.
diff --git a/docs/overview.md b/docs/overview.md
index 28cce70b..639629e1 100644
--- a/docs/overview.md
+++ b/docs/overview.md
@@ -22,14 +22,15 @@ The **MCP management** section provides setup and management for MCP (Model Cont
 
 - **Overview** - when no MCPGatewayExtensions exist, shows a guided setup wizard for creating MCP infrastructure. Once extensions are created, shows a dashboard with summary cards for MCP Gateways (Total, Healthy, Unhealthy) and MCP Servers (Types, Total, Online, Offline). Includes tables for MCP Gateway Extensions, MCP Servers, Reference Grants, and Policies attached to MCP gateways or servers. Each table has toolbar filters and RBAC-aware create actions.
 - **MCP Gateway Setup Wizard** - 4-step wizard that walks through selecting or creating a Gateway, HTTPRoute, and MCPGatewayExtension resource. Supports both existing resource selection and inline creation of new resources. Resources are created sequentially in the final verification step, with live status watching for the MCPGatewayExtension Ready condition.
+- **MCP Inspector** - connects the browser directly to a Ready MCPGatewayExtension, lists and refreshes tools, creates inputs from each tool's JSON schema, and displays tool results with JSON-RPC request telemetry. See the [MCP Inspector guide](mcp-inspector.md).
 
 Key resources managed on this page:
 
-| Resource | API Group | Purpose |
-|-|-|-|
-| `MCPGatewayExtension` | `mcp.kuadrant.io/v1` | Extends a Gateway with MCP capabilities (public host, OAuth, session store) |
-| `MCPServerRegistration` | `mcp.kuadrant.io/v1` | Registers an MCP server behind an HTTPRoute with prefix routing |
-| `ReferenceGrant` | `gateway.networking.k8s.io/v1beta1` | Allows cross-namespace references between MCPGatewayExtensions and Gateways |
+| Resource                | API Group                           | Purpose                                                                     |
+| ----------------------- | ----------------------------------- | --------------------------------------------------------------------------- |
+| `MCPGatewayExtension`   | `mcp.kuadrant.io/v1`                | Extends a Gateway with MCP capabilities (public host, OAuth, session store) |
+| `MCPServerRegistration` | `mcp.kuadrant.io/v1`                | Registers an MCP server behind an HTTPRoute with prefix routing             |
+| `ReferenceGrant`        | `gateway.networking.k8s.io/v1beta1` | Allows cross-namespace references between MCPGatewayExtensions and Gateways |
 
 MCP Gateways are identified by finding Gateway resources that have an MCPGatewayExtension targeting them via `spec.targetRef`. The summary cards compute health based on the Gateway's `Accepted` and `Programmed` conditions, and server readiness based on the `Ready` condition.
 
diff --git a/e2e/tests/mcp-inspector.spec.ts b/e2e/tests/mcp-inspector.spec.ts
new file mode 100644
index 00000000..18622827
--- /dev/null
+++ b/e2e/tests/mcp-inspector.spec.ts
@@ -0,0 +1,66 @@
+import { test, expect } from '@playwright/test';
+import { dismissConsoleTour, spaNavigate, TEST_NAMESPACE } from './helpers';
+
+const integrationExtension = process.env.MCP_INSPECTOR_E2E_EXTENSION;
+const integrationTool = process.env.MCP_INSPECTOR_E2E_TOOL || 'toystore_greet';
+const integrationArgumentLabel = process.env.MCP_INSPECTOR_E2E_ARGUMENT_LABEL || 'Name';
+const integrationArgumentValue = process.env.MCP_INSPECTOR_E2E_ARGUMENT_VALUE || 'Ada';
+
+async function openInspector(page, namespace: string): Promise<void> {
+  await page.goto(`/k8s/ns/${namespace}`);
+  await page.waitForLoadState('networkidle');
+  await dismissConsoleTour(page);
+  await spaNavigate(page, '/mcp-inspector');
+}
+
+test.describe('MCP Inspector', () => {
+  test('opens from the console and prompts for a gateway', { tag: '@smoke' }, async ({ page }) => {
+    await openInspector(page, TEST_NAMESPACE);
+
+    await expect(page.getByRole('heading', { name: 'MCP Inspector' })).toBeVisible({
+      timeout: 15_000,
+    });
+    await expect(page.getByLabel('Select an MCP gateway extension')).toBeVisible();
+    await expect(page.getByRole('heading', { name: 'No connection' })).toBeVisible();
+  });
+
+  test('connects to a live gateway and runs a tool', { tag: '@nightly' }, async ({ page }) => {
+    test.skip(
+      !integrationExtension,
+      'Set MCP_INSPECTOR_E2E_EXTENSION=namespace/name to run the live integration journey.',
+    );
+    const [namespace, extensionName] = integrationExtension!.split('/');
+    expect(namespace).toBeTruthy();
+    expect(extensionName).toBeTruthy();
+
+    await openInspector(page, namespace);
+    await page
+      .getByLabel('Select an MCP gateway extension')
+      .selectOption(`${namespace}/${extensionName}`);
+
+    await expect(page.getByText('Connected', { exact: true })).toBeVisible({ timeout: 20_000 });
+    const refreshToolsButton = page.getByRole('button', { name: 'Refresh tools' });
+    await refreshToolsButton.click();
+    await expect(refreshToolsButton).toBeEnabled();
+    await page.getByLabel('Search tools').fill(integrationTool);
+    await page.getByRole('button', { name: integrationTool, exact: true }).click();
+    await page.getByLabel(integrationArgumentLabel).fill(integrationArgumentValue);
+    await page.getByRole('button', { name: 'Run tool' }).click();
+
+    await expect(page.getByText('Success', { exact: true })).toBeVisible({ timeout: 20_000 });
+    const summaryTextCenters = await page
+      .locator('.kuadrant-mcp-inspector-page__request-summary > *')
+      .evaluateAll((items) =>
+        items.map((item) => {
+          const range = document.createRange();
+          range.selectNodeContents(item);
+          const rect = range.getBoundingClientRect();
+          return rect.top + rect.height / 2;
+        }),
+      );
+    expect(Math.max(...summaryTextCenters) - Math.min(...summaryTextCenters)).toBeLessThanOrEqual(
+      1,
+    );
+    await expect(page.getByRole('heading', { name: 'JSON-RPC response' })).toBeVisible();
+  });
+});
diff --git a/locales/en/plugin__kuadrant-console-plugin.json b/locales/en/plugin__kuadrant-console-plugin.json
index 7277e557..5bb1f10c 100644
--- a/locales/en/plugin__kuadrant-console-plugin.json
+++ b/locales/en/plugin__kuadrant-console-plugin.json
@@ -847,30 +847,68 @@
   "You do not have permission to view Reference grants": "You do not have permission to view Reference grants",
   "You do not have permission to view this resource": "You do not have permission to view this resource",
   "MCP Inspector": "MCP Inspector",
-  "Throwaway proof-of-concept: the browser speaks MCP Streamable HTTP directly to a gateway endpoint. Calls are cross-origin.": "Throwaway proof-of-concept: the browser speaks MCP Streamable HTTP directly to a gateway endpoint. Calls are cross-origin.",
-  "Browser origin": "Browser origin",
-  "MCP gateway extension": "MCP gateway extension",
   "Select an MCP gateway extension": "Select an MCP gateway extension",
   "Loading extensions...": "Loading extensions...",
   "Select an extension...": "Select an extension...",
   "not reachable": "not reachable",
-  "Resolved endpoint": "Resolved endpoint",
-  "none": "none",
-  "Bearer token (optional)": "Bearer token (optional)",
   "Held in memory only": "Held in memory only",
-  "Connect + list tools": "Connect + list tools",
   "Session ID": "Session ID",
   "Session expired, reconnect": "Session expired, reconnect",
   "The MCP session is no longer valid. Connect again to start a new session.": "The MCP session is no longer valid. Connect again to start a new session.",
-  "initialize": "initialize",
-  "tools/list": "tools/list",
-  "Call a tool": "Call a tool",
-  "Tool": "Tool",
   "Select a tool": "Select a tool",
-  "Select a tool...": "Select a tool...",
-  "Arguments (JSON)": "Arguments (JSON)",
-  "Tool call arguments as JSON": "Tool call arguments as JSON",
-  "Call": "Call",
-  "tools/call result": "tools/call result",
-  "Arguments must be valid JSON": "Arguments must be valid JSON"
+  "Add metadata": "Add metadata",
+  "Authenticated": "Authenticated",
+  "Authentication required": "Authentication required",
+  "Bearer token": "Bearer token",
+  "Connect to a Gateway to view the MCP server tools available.": "Connect to a Gateway to view the MCP server tools available.",
+  "Connect with bearer token": "Connect with bearer token",
+  "Connected": "Connected",
+  "Connecting...": "Connecting...",
+  "Connection": "Connection",
+  "Console": "Console",
+  "Destructive": "Destructive",
+  "errors": "errors",
+  "Gateway": "Gateway",
+  "Idempotent": "Idempotent",
+  "Input is valid": "Input is valid",
+  "JSON-RPC request": "JSON-RPC request",
+  "JSON-RPC response": "JSON-RPC response",
+  "Logs": "Logs",
+  "MCP inspector sections": "MCP inspector sections",
+  "Metadata": "Metadata",
+  "Metadata key": "Metadata key",
+  "Metadata value": "Metadata value",
+  "No authentication": "No authentication",
+  "No connection": "No connection",
+  "No description": "No description",
+  "No results": "No results",
+  "No tools found": "No tools found",
+  "Open world": "Open world",
+  "Optional key-value metadata is sent with the MCP tool call.": "Optional key-value metadata is sent with the MCP tool call.",
+  "Output": "Output",
+  "Prompt inspection is not available yet.": "Prompt inspection is not available yet.",
+  "Prompts": "Prompts",
+  "Read only": "Read only",
+  "Refresh tools": "Refresh tools",
+  "Remove metadata": "Remove metadata",
+  "request": "request",
+  "requests": "requests",
+  "Run tool": "Run tool",
+  "Running tools executes live server-side code and can change your infrastructure.": "Running tools executes live server-side code and can change your infrastructure.",
+  "Search tools": "Search tools",
+  "Select a tool to inspect and run it.": "Select a tool to inspect and run it.",
+  "Select a value...": "Select a value...",
+  "Server": "Server",
+  "Server result": "Server result",
+  "Session logs are not available yet.": "Session logs are not available yet.",
+  "Sign in with OIDC": "Sign in with OIDC",
+  "This MCP gateway requires authentication. Sign in with OIDC or provide a bearer token.": "This MCP gateway requires authentication. Sign in with OIDC or provide a bearer token.",
+  "Tool call output": "Tool call output",
+  "Tools": "Tools",
+  "Validate only": "Validate only",
+  "warnings": "warnings",
+  "{{field}} is required": "{{field}} is required",
+  "{{field}} must be an integer": "{{field}} must be an integer",
+  "{{field}} must be a number": "{{field}} must be a number",
+  "{{field}} must be valid JSON": "{{field}} must be valid JSON"
 }
diff --git a/src/components/mcp/MCPInspectorOutput.tsx b/src/components/mcp/MCPInspectorOutput.tsx
new file mode 100644
index 00000000..c8c9f4ff
--- /dev/null
+++ b/src/components/mcp/MCPInspectorOutput.tsx
@@ -0,0 +1,82 @@
+import * as React from 'react';
+import { useTranslation } from 'react-i18next';
+import {
+  Card,
+  CardBody,
+  CardHeader,
+  CardTitle,
+  Content,
+  Label,
+  Tab,
+  Tabs,
+  TabTitleText,
+  Title,
+} from '@patternfly/react-core';
+import { MCPCallExchange, ToolsCallResult } from '../../utils/mcp/client';
+
+interface MCPInspectorOutputProps {
+  exchange: MCPCallExchange<ToolsCallResult> | null;
+}
+
+const renderServerResult = (result: ToolsCallResult): React.ReactNode => {
+  if (!result.content?.length) {
+    return <pre>{JSON.stringify(result, null, 2)}</pre>;
+  }
+  return result.content.map((content, index) =>
+    content.type === 'text' && content.text ? (
+      <pre key={index}>{content.text}</pre>
+    ) : (
+      <pre key={index}>{JSON.stringify(content, null, 2)}</pre>
+    ),
+  );
+};
+
+const MCPInspectorOutput: React.FC<MCPInspectorOutputProps> = ({ exchange }) => {
+  const { t } = useTranslation('plugin__kuadrant-console-plugin');
+  const [activeTab, setActiveTab] = React.useState<string | number>(0);
+  const succeeded = exchange ? !exchange.result.isError : false;
+
+  return (
+    <Card isFullHeight className="kuadrant-mcp-inspector-page__output">
+      <CardHeader>
+        <CardTitle>{t('Output')}</CardTitle>
+      </CardHeader>
+      <CardBody>
+        {exchange && (
+          <div className="kuadrant-mcp-inspector-page__request-summary">
+            <Label color={succeeded ? 'green' : 'red'}>
+              {succeeded ? t('Success') : t('Error')}
+            </Label>
+            <small>
+              {exchange.status} {exchange.statusText}
+            </small>
+            <small>{exchange.durationMs} ms</small>
+          </div>
+        )}
+        <Tabs
+          activeKey={activeTab}
+          onSelect={(_event, key) => setActiveTab(key)}
+          aria-label={t('Tool call output')}
+        >
+          <Tab eventKey={0} title={<TabTitleText>{t('Console')}</TabTitleText>}>
+            {exchange ? (
+              <div className="kuadrant-mcp-inspector-page__console">
+                <Title headingLevel="h3">{t('JSON-RPC request')}</Title>
+                <pre>{JSON.stringify(exchange.request, null, 2)}</pre>
+                <Title headingLevel="h3">{t('JSON-RPC response')}</Title>
+                <pre>{JSON.stringify(exchange.response, null, 2)}</pre>
+              </div>
+            ) : (
+              <Content component="p">{t('No results')}</Content>
+            )}
+          </Tab>
+          <Tab eventKey={1} title={<TabTitleText>{t('Server result')}</TabTitleText>}>
+            {exchange ? renderServerResult(exchange.result) : null}
+          </Tab>
+        </Tabs>
+      </CardBody>
+    </Card>
+  );
+};
+
+export default MCPInspectorOutput;
diff --git a/src/components/mcp/MCPInspectorPage.css b/src/components/mcp/MCPInspectorPage.css
new file mode 100644
index 00000000..e7ef753e
--- /dev/null
+++ b/src/components/mcp/MCPInspectorPage.css
@@ -0,0 +1,194 @@
+.kuadrant-mcp-inspector-page {
+  --kuadrant-mcp-inspector-border: var(--pf-t--global--border--color--default, #d2d2d2);
+}
+
+.kuadrant-mcp-inspector-page__connection-card {
+  border: 1px solid var(--kuadrant-mcp-inspector-border);
+  border-radius: var(--pf-t--global--border--radius--large, 12px);
+  box-shadow: none;
+}
+
+.kuadrant-mcp-inspector-page__connection-card .pf-v6-c-card__body {
+  padding: var(--pf-t--global--spacer--lg, 1.5rem);
+}
+
+.kuadrant-mcp-inspector-page__connection-segment {
+  min-height: 5.5rem;
+  padding: 0 var(--pf-t--global--spacer--xl, 2rem);
+}
+
+.kuadrant-mcp-inspector-page__connection-segment:first-child {
+  padding-left: 0;
+}
+
+.kuadrant-mcp-inspector-page__connection-segment
+  + .kuadrant-mcp-inspector-page__connection-segment {
+  border-left: 1px solid var(--kuadrant-mcp-inspector-border);
+}
+
+.kuadrant-mcp-inspector-page__connection-segment:last-child {
+  padding-right: 0;
+}
+
+.kuadrant-mcp-inspector-page__connection-segment .pf-v6-c-form__label,
+.kuadrant-mcp-inspector-page__segment-title {
+  display: block;
+  margin-bottom: var(--pf-t--global--spacer--sm, 0.5rem);
+  font-weight: var(--pf-t--global--font--weight--body--bold, 700);
+  text-align: center;
+}
+
+.kuadrant-mcp-inspector-page__endpoint {
+  display: block;
+  overflow: hidden;
+  margin-top: var(--pf-t--global--spacer--xs, 0.25rem);
+  color: var(--pf-t--global--text--color--subtle, #6a6e73);
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.kuadrant-mcp-inspector-page__connection-status,
+.kuadrant-mcp-inspector-page__session-status,
+.kuadrant-mcp-inspector-page__request-summary {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: center;
+  gap: var(--pf-t--global--spacer--md, 1rem);
+}
+
+.kuadrant-mcp-inspector-page__session-status span + span {
+  padding-left: var(--pf-t--global--spacer--md, 1rem);
+  border-left: 1px solid var(--kuadrant-mcp-inspector-border);
+}
+
+.kuadrant-mcp-inspector-page__status-dot {
+  width: 0.75rem;
+  height: 0.75rem;
+  border-radius: 50%;
+  background: var(--pf-t--global--color--status--danger--default, #c9190b);
+}
+
+.kuadrant-mcp-inspector-page__status-dot.is-connected {
+  background: var(--pf-t--global--color--status--success--default, #3e8635);
+}
+
+.kuadrant-mcp-inspector-page__session-id {
+  display: block;
+  overflow: hidden;
+  margin-top: var(--pf-t--global--spacer--sm, 0.5rem);
+  text-align: center;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.kuadrant-mcp-inspector-page__section {
+  padding-top: var(--pf-t--global--spacer--lg, 1.5rem);
+}
+
+.kuadrant-mcp-inspector-page__tool-warning {
+  max-width: 42rem;
+  margin: 0 auto;
+}
+
+.kuadrant-mcp-inspector-page__workspace,
+.kuadrant-mcp-inspector-page__output {
+  border: 1px solid var(--kuadrant-mcp-inspector-border);
+  border-radius: var(--pf-t--global--border--radius--large, 12px);
+  box-shadow: none;
+}
+
+.kuadrant-mcp-inspector-page__tool-list {
+  display: flex;
+  max-height: 10rem;
+  flex-direction: column;
+  overflow-y: auto;
+  margin: var(--pf-t--global--spacer--sm, 0.5rem) 0;
+  border: 1px solid var(--kuadrant-mcp-inspector-border);
+  border-radius: var(--pf-t--global--border--radius--small, 4px);
+}
+
+.kuadrant-mcp-inspector-page__tool {
+  width: 100%;
+  justify-content: flex-start;
+  border-radius: 0;
+  text-align: left;
+}
+
+.kuadrant-mcp-inspector-page__tool.is-selected {
+  background: var(--pf-t--global--background--color--primary--hover, #f0f0f0);
+}
+
+.kuadrant-mcp-inspector-page__selected-tool {
+  padding-top: var(--pf-t--global--spacer--md, 1rem);
+  border-top: 1px solid var(--kuadrant-mcp-inspector-border);
+}
+
+.kuadrant-mcp-inspector-page__annotations,
+.kuadrant-mcp-inspector-page__tool-form,
+.kuadrant-mcp-inspector-page__metadata {
+  margin-top: var(--pf-t--global--spacer--md, 1rem);
+}
+
+.kuadrant-mcp-inspector-page__field-error {
+  color: var(--pf-t--global--color--status--danger--default, #c9190b);
+}
+
+.kuadrant-mcp-inspector-page__metadata-heading,
+.kuadrant-mcp-inspector-page__metadata-row,
+.kuadrant-mcp-inspector-page__actions {
+  display: flex;
+  align-items: center;
+  gap: var(--pf-t--global--spacer--md, 1rem);
+}
+
+.kuadrant-mcp-inspector-page__metadata-heading {
+  justify-content: space-between;
+}
+
+.kuadrant-mcp-inspector-page__metadata-row {
+  margin-top: var(--pf-t--global--spacer--sm, 0.5rem);
+}
+
+.kuadrant-mcp-inspector-page__metadata-row > *:not(:last-child) {
+  flex: 1;
+}
+
+.kuadrant-mcp-inspector-page__actions {
+  margin-top: var(--pf-t--global--spacer--lg, 1.5rem);
+}
+
+.kuadrant-mcp-inspector-page__request-summary {
+  justify-content: flex-start;
+  margin-bottom: var(--pf-t--global--spacer--sm, 0.5rem);
+}
+
+.kuadrant-mcp-inspector-page__console pre,
+.kuadrant-mcp-inspector-page__output pre {
+  max-height: 20rem;
+  overflow: auto;
+  padding: var(--pf-t--global--spacer--md, 1rem);
+  margin: var(--pf-t--global--spacer--sm, 0.5rem) 0 var(--pf-t--global--spacer--md, 1rem);
+  border-radius: var(--pf-t--global--border--radius--small, 4px);
+  background: var(--pf-t--global--background--color--secondary--default, #f5f5f5);
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+@media (max-width: 768px) {
+  .kuadrant-mcp-inspector-page__connection-segment {
+    min-height: auto;
+    padding: var(--pf-t--global--spacer--md, 1rem) 0;
+  }
+
+  .kuadrant-mcp-inspector-page__connection-segment
+    + .kuadrant-mcp-inspector-page__connection-segment {
+    border-top: 1px solid var(--kuadrant-mcp-inspector-border);
+    border-left: 0;
+  }
+
+  .kuadrant-mcp-inspector-page__metadata-row {
+    align-items: stretch;
+    flex-direction: column;
+  }
+}
diff --git a/src/components/mcp/MCPInspectorPage.test.tsx b/src/components/mcp/MCPInspectorPage.test.tsx
new file mode 100644
index 00000000..8eb5e090
--- /dev/null
+++ b/src/components/mcp/MCPInspectorPage.test.tsx
@@ -0,0 +1,254 @@
+import * as React from 'react';
+import '@testing-library/jest-dom';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { MCPGatewayExtension } from './types';
+import { MCPClient, MCPUnauthorizedError } from '../../utils/mcp/client';
+
+let mockExtensions: MCPGatewayExtension[] = [];
+let mockExtensionsLoaded = true;
+let mockToolsCallWithDetails = jest.fn();
+let mockToolsList = jest.fn();
+
+jest.mock('react-i18next', () => ({
+  useTranslation: () => ({
+    t: (key: string, values?: Record<string, string>) =>
+      Object.entries(values ?? {}).reduce(
+        (translated, [name, value]) => translated.replace(`{{${name}}}`, value),
+        key,
+      ),
+  }),
+}));
+
+jest.mock('react-helmet', () => ({
+  __esModule: true,
+  default: ({ children }: { children: React.ReactNode }) => <>{children}</>,
+}));
+
+jest.mock('@openshift-console/dynamic-plugin-sdk', () => ({
+  NamespaceBar: () => <div data-test="namespace-bar" />,
+  useActiveNamespace: () => ['test-ns'],
+  useK8sWatchResource: () => [mockExtensions, mockExtensionsLoaded, null],
+}));
+
+jest.mock('../../utils/mcp/client', () => ({
+  ...jest.requireActual('../../utils/mcp/client'),
+  MCPClient: jest.fn(),
+}));
+
+import MCPInspectorPage from './MCPInspectorPage';
+
+const readyExtension: MCPGatewayExtension = {
+  apiVersion: 'mcp.kuadrant.io/v1',
+  kind: 'MCPGatewayExtension',
+  metadata: { name: 'mcp-gateway', namespace: 'test-ns' },
+  spec: {
+    targetRef: {
+      name: 'mcp-gateway',
+      sectionName: 'mcp',
+    },
+  },
+  status: {
+    conditions: [{ type: 'Ready', status: 'True' }],
+    mcpEndpoint: 'https://mcp.example.test/mcp',
+  },
+};
+
+describe('MCPInspectorPage', () => {
+  beforeEach(() => {
+    mockExtensions = [];
+    mockExtensionsLoaded = true;
+    mockToolsCallWithDetails = jest.fn().mockResolvedValue({
+      result: { content: [{ type: 'text', text: 'Hello, Ada!' }] },
+      request: {
+        jsonrpc: '2.0',
+        id: 3,
+        method: 'tools/call',
+        params: { name: 'toystore_greet', arguments: { name: 'Ada' } },
+      },
+      response: {
+        jsonrpc: '2.0',
+        id: 3,
+        result: { content: [{ type: 'text', text: 'Hello, Ada!' }] },
+      },
+      status: 200,
+      statusText: 'OK',
+      durationMs: 12,
+    });
+    mockToolsList = jest.fn().mockResolvedValue({
+      tools: [
+        {
+          name: 'toystore_greet',
+          description: 'Say hello',
+          annotations: { readOnlyHint: true },
+          inputSchema: {
+            type: 'object',
+            properties: {
+              name: { type: 'string', description: 'The name to greet' },
+            },
+            required: ['name'],
+          },
+        },
+      ],
+    });
+    (MCPClient as jest.Mock).mockReset();
+    (MCPClient as jest.Mock).mockImplementation(() => ({
+      initialize: jest.fn().mockResolvedValue({
+        result: {
+          protocolVersion: '2025-11-25',
+          serverInfo: { name: 'test-server', version: '1.0.0' },
+        },
+        sessionId: 'session-1',
+      }),
+      sendInitialized: jest.fn().mockResolvedValue(undefined),
+      toolsList: mockToolsList,
+      toolsCallWithDetails: mockToolsCallWithDetails,
+    }));
+  });
+
+  it('guides the user to select a gateway before showing inspector tools', () => {
+    render(<MCPInspectorPage />);
+
+    expect(screen.getByRole('heading', { name: 'No connection' })).toBeInTheDocument();
+    expect(
+      screen.getByText('Connect to a Gateway to view the MCP server tools available.'),
+    ).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: 'Run tool' })).not.toBeInTheDocument();
+  });
+
+  it('connects to a ready gateway and shows its tools workspace', async () => {
+    mockExtensions = [readyExtension];
+    render(<MCPInspectorPage />);
+
+    fireEvent.change(screen.getByLabelText('Select an MCP gateway extension'), {
+      target: { value: 'test-ns/mcp-gateway' },
+    });
+
+    await waitFor(() => expect(screen.getByText('Connected')).toBeInTheDocument());
+    expect(screen.getByRole('tab', { name: 'Tools' })).toBeInTheDocument();
+    expect(screen.getAllByText('toystore_greet').length).toBeGreaterThan(0);
+    expect(screen.queryByLabelText('Bearer token (optional)')).not.toBeInTheDocument();
+    expect(screen.getByText('0 requests')).toBeInTheDocument();
+    expect(screen.getByText('0 warnings')).toBeInTheDocument();
+    expect(screen.getByText('0 errors')).toBeInTheDocument();
+    expect(screen.getByText('No results')).toBeInTheDocument();
+  });
+
+  it('offers OIDC and an in-memory bearer token after an authentication challenge', async () => {
+    (MCPClient as jest.Mock).mockImplementationOnce(() => ({
+      initialize: jest
+        .fn()
+        .mockRejectedValue(
+          new MCPUnauthorizedError(
+            'Bearer resource_metadata="https://mcp.example.test/.well-known/oauth-protected-resource/mcp"',
+          ),
+        ),
+    }));
+    mockExtensions = [readyExtension];
+    render(<MCPInspectorPage />);
+
+    fireEvent.change(screen.getByLabelText('Select an MCP gateway extension'), {
+      target: { value: 'test-ns/mcp-gateway' },
+    });
+
+    const dialog = await screen.findByRole('dialog', { name: 'Authentication required' });
+    expect(dialog).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: 'Sign in with OIDC' })).toBeInTheDocument();
+
+    fireEvent.change(screen.getByLabelText('Bearer token'), { target: { value: 'test-token' } });
+    fireEvent.click(screen.getByRole('button', { name: 'Connect with bearer token' }));
+
+    await waitFor(() => expect(screen.getByText('Connected')).toBeInTheDocument());
+    expect(MCPClient).toHaveBeenLastCalledWith('https://mcp.example.test/mcp', {
+      token: 'test-token',
+    });
+    expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
+  });
+
+  it('builds and validates a tool form from its input schema before running it', async () => {
+    mockExtensions = [readyExtension];
+    render(<MCPInspectorPage />);
+
+    fireEvent.change(screen.getByLabelText('Select an MCP gateway extension'), {
+      target: { value: 'test-ns/mcp-gateway' },
+    });
+    await waitFor(() => expect(screen.getByText('Connected')).toBeInTheDocument());
+
+    fireEvent.change(screen.getByLabelText('Search tools'), { target: { value: 'greet' } });
+    fireEvent.click(screen.getByRole('button', { name: /toystore_greet/ }));
+
+    expect(screen.getByRole('heading', { name: 'toystore_greet' })).toBeInTheDocument();
+    expect(screen.getByText('Read only')).toBeInTheDocument();
+    fireEvent.click(screen.getByRole('button', { name: 'Validate only' }));
+    expect(screen.getByText('Name is required')).toBeInTheDocument();
+
+    fireEvent.change(screen.getByLabelText('Name'), { target: { value: 'Ada' } });
+    fireEvent.click(screen.getByRole('button', { name: 'Validate only' }));
+    expect(screen.getByText('Input is valid')).toBeInTheDocument();
+
+    fireEvent.click(screen.getByRole('button', { name: 'Run tool' }));
+    await waitFor(() =>
+      expect(mockToolsCallWithDetails).toHaveBeenCalledWith('toystore_greet', { name: 'Ada' }),
+    );
+  });
+
+  it('sends metadata and presents the server result with request telemetry', async () => {
+    mockExtensions = [readyExtension];
+    render(<MCPInspectorPage />);
+
+    fireEvent.change(screen.getByLabelText('Select an MCP gateway extension'), {
+      target: { value: 'test-ns/mcp-gateway' },
+    });
+    await waitFor(() => expect(screen.getByText('Connected')).toBeInTheDocument());
+    fireEvent.click(screen.getByRole('button', { name: /toystore_greet/ }));
+    fireEvent.change(screen.getByLabelText('Name'), { target: { value: 'Ada' } });
+    fireEvent.click(screen.getByRole('button', { name: 'Add metadata' }));
+    fireEvent.change(screen.getByLabelText('Metadata key'), { target: { value: 'traceId' } });
+    fireEvent.change(screen.getByLabelText('Metadata value'), {
+      target: { value: 'trace-1' },
+    });
+
+    fireEvent.click(screen.getByRole('button', { name: 'Run tool' }));
+
+    await waitFor(() =>
+      expect(mockToolsCallWithDetails).toHaveBeenCalledWith(
+        'toystore_greet',
+        { name: 'Ada' },
+        { traceId: 'trace-1' },
+      ),
+    );
+    expect(screen.getByText('Success')).toBeInTheDocument();
+    expect(screen.getByText('200 OK')).toBeInTheDocument();
+    expect(screen.getByText('12 ms')).toBeInTheDocument();
+    expect(screen.getByRole('tab', { name: 'Console' })).toBeInTheDocument();
+    expect(screen.getByRole('tab', { name: 'Server result' })).toBeInTheDocument();
+    expect(screen.getAllByText(/Hello, Ada!/).length).toBeGreaterThan(0);
+  });
+
+  it('refreshes the tool list without reconnecting the session', async () => {
+    mockToolsList
+      .mockResolvedValueOnce({
+        tools: [{ name: 'toystore_greet', inputSchema: { type: 'object', properties: {} } }],
+      })
+      .mockResolvedValueOnce({
+        tools: [
+          { name: 'toystore_greet', inputSchema: { type: 'object', properties: {} } },
+          { name: 'toystore_calculate', inputSchema: { type: 'object', properties: {} } },
+        ],
+      });
+    mockExtensions = [readyExtension];
+    render(<MCPInspectorPage />);
+
+    fireEvent.change(screen.getByLabelText('Select an MCP gateway extension'), {
+      target: { value: 'test-ns/mcp-gateway' },
+    });
+    await waitFor(() => expect(screen.getByText('Connected')).toBeInTheDocument());
+
+    const refreshButton = screen.getByRole('button', { name: 'Refresh tools' });
+    expect(refreshButton).not.toHaveTextContent('Refresh');
+    fireEvent.click(refreshButton);
+
+    await waitFor(() => expect(screen.getByText('toystore_calculate')).toBeInTheDocument());
+    expect(mockToolsList).toHaveBeenCalledTimes(2);
+    expect(MCPClient).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/src/components/mcp/MCPInspectorPage.tsx b/src/components/mcp/MCPInspectorPage.tsx
index 4b9d713f..7b235984 100644
--- a/src/components/mcp/MCPInspectorPage.tsx
+++ b/src/components/mcp/MCPInspectorPage.tsx
@@ -9,13 +9,26 @@ import {
   FormGroup,
   FormSelect,
   FormSelectOption,
-  TextInput,
-  TextArea,
   Button,
   Alert,
   Stack,
   StackItem,
   Divider,
+  EmptyState,
+  EmptyStateBody,
+  Tab,
+  Tabs,
+  TabTitleText,
+  Modal,
+  ModalBody,
+  ModalFooter,
+  ModalHeader,
+  ModalVariant,
+  TextInput,
+  Card,
+  CardBody,
+  Grid,
+  GridItem,
 } from '@patternfly/react-core';
 import {
   NamespaceBar,
@@ -27,24 +40,25 @@ import { MCPGatewayExtension } from './types';
 import {
   MCPClient,
   MCPSessionExpiredError,
+  MCPUnauthorizedError,
   MCPTool,
-  InitializeResult,
-  ToolsListResult,
   ToolsCallResult,
+  MCPCallExchange,
 } from '../../utils/mcp/client';
+import {
+  beginPkce,
+  clearPkceStorage,
+  completePkce,
+  peekOauthCallback,
+  stashOauthCallback,
+  takeOauthExchangeLock,
+} from '../../utils/mcp/oauth';
+import MCPToolWorkspace from './MCPToolWorkspace';
+import MCPInspectorOutput from './MCPInspectorOutput';
+import './MCPInspectorPage.css';
 
 const ALL_NS = '#ALL_NS#';
 
-const preStyle: React.CSSProperties = {
-  whiteSpace: 'pre-wrap',
-  wordBreak: 'break-word',
-  overflow: 'auto',
-  maxHeight: '20rem',
-  padding: 'var(--pf-t--global--spacer--md, 1rem)',
-  background: 'var(--pf-t--global--background--color--secondary--default, #f5f5f5)',
-  borderRadius: 'var(--pf-t--global--border--radius--small, 4px)',
-};
-
 const isReady = (ext: MCPGatewayExtension): boolean =>
   (ext.status?.conditions ?? []).some((c) => c.type === 'Ready' && c.status === 'True');
 
@@ -63,22 +77,34 @@ const MCPInspectorPage: React.FC = () => {
   });
 
   const [selectedKey, setSelectedKey] = React.useState('');
-  const [token, setToken] = React.useState('');
+  const [bearerToken, setBearerToken] = React.useState('');
+  const [authChallenge, setAuthChallenge] = React.useState<{
+    mcpEndpoint: string;
+    selectedKey: string;
+    wwwAuthenticate: string | null;
+  } | null>(null);
 
   // session id lives in react state and on the client instance only, never localStorage.
   const clientRef = React.useRef<MCPClient | null>(null);
   const [sessionId, setSessionId] = React.useState<string | null>(null);
-
-  const [initResult, setInitResult] = React.useState<InitializeResult | null>(null);
-  const [toolsResult, setToolsResult] = React.useState<ToolsListResult | null>(null);
+  const [connected, setConnected] = React.useState(false);
+  const [authMode, setAuthMode] = React.useState<'none' | 'bearer' | 'oidc'>('none');
+  const [activeSection, setActiveSection] = React.useState<string | number>(0);
   const [tools, setTools] = React.useState<MCPTool[]>([]);
 
-  const [selectedTool, setSelectedTool] = React.useState('');
-  const [argsText, setArgsText] = React.useState('{}');
-  const [callResult, setCallResult] = React.useState<ToolsCallResult | null>(null);
+  const [callExchange, setCallExchange] = React.useState<MCPCallExchange<ToolsCallResult> | null>(
+    null,
+  );
+  const [stats, setStats] = React.useState({
+    calls: 0,
+    succeeded: 0,
+    failed: 0,
+    totalDurationMs: 0,
+  });
 
   const [connecting, setConnecting] = React.useState(false);
   const [calling, setCalling] = React.useState(false);
+  const [refreshingTools, setRefreshingTools] = React.useState(false);
   const [error, setError] = React.useState('');
   const [sessionExpired, setSessionExpired] = React.useState(false);
 
@@ -88,59 +114,171 @@ const MCPInspectorPage: React.FC = () => {
     [list, selectedKey],
   );
   const endpoint = selected?.status?.mcpEndpoint ?? '';
-  const origin = window.location.origin;
 
-  const handleConnect = async () => {
-    if (!endpoint) {
-      return;
-    }
+  const runSession = async (mcpEndpoint: string, bearer?: string) => {
     setError('');
     setSessionExpired(false);
-    setConnecting(true);
-    setInitResult(null);
-    setToolsResult(null);
     setTools([]);
-    setSelectedTool('');
-    setCallResult(null);
+    setCallExchange(null);
+    const client = new MCPClient(mcpEndpoint, { token: bearer || undefined });
+    const { sessionId: id } = await client.initialize();
+    await client.sendInitialized();
+    const listed = await client.toolsList();
+    clientRef.current = client;
+    setSessionId(id);
+    setConnected(true);
+    setTools(listed.tools ?? []);
+  };
+
+  const handleConnect = async (
+    mcpEndpoint = endpoint,
+    selectedExtensionKey = selectedKey,
+    bearer?: string,
+  ) => {
+    if (!mcpEndpoint) {
+      return;
+    }
+    setConnecting(true);
     try {
-      const client = new MCPClient(endpoint, { token: token || undefined });
-      const { result, sessionId: id } = await client.initialize();
-      await client.sendInitialized();
-      const listed = await client.toolsList();
-      clientRef.current = client;
-      setSessionId(id);
-      setInitResult(result);
-      setToolsResult(listed);
-      setTools(listed.tools ?? []);
+      await runSession(mcpEndpoint, bearer);
+      setAuthMode(bearer ? 'bearer' : 'none');
+      setAuthChallenge(null);
     } catch (err) {
       clientRef.current = null;
       setSessionId(null);
-      setError(err instanceof Error ? err.message : String(err));
+      setConnected(false);
+      if (err instanceof MCPUnauthorizedError && !bearer) {
+        setError('');
+        setAuthChallenge({
+          mcpEndpoint,
+          selectedKey: selectedExtensionKey,
+          wwwAuthenticate: err.wwwAuthenticate,
+        });
+      } else {
+        setError(err instanceof Error ? err.message : String(err));
+      }
     } finally {
       setConnecting(false);
     }
   };
 
-  const handleCall = async () => {
-    const client = clientRef.current;
-    if (!client || !selectedTool) {
+  const handleGatewayChange = (_event: React.FormEvent<HTMLSelectElement>, value: string) => {
+    setSelectedKey(value);
+    clientRef.current = null;
+    setSessionId(null);
+    setConnected(false);
+    setAuthMode('none');
+    setActiveSection(0);
+    setTools([]);
+    setCallExchange(null);
+    setStats({ calls: 0, succeeded: 0, failed: 0, totalDurationMs: 0 });
+    setError('');
+    setSessionExpired(false);
+    setAuthChallenge(null);
+    setBearerToken('');
+    if (!value) {
       return;
     }
-    let parsedArgs: Record<string, unknown>;
+    const extension = list.find((item) => extKey(item) === value);
+    if (extension?.status?.mcpEndpoint && isReady(extension)) {
+      void handleConnect(extension.status.mcpEndpoint, value);
+    }
+  };
+
+  const handleOidcSignIn = async () => {
+    if (!authChallenge) {
+      return;
+    }
+    setConnecting(true);
+    setError('');
     try {
-      parsedArgs = argsText.trim() === '' ? {} : JSON.parse(argsText);
-    } catch {
-      setError(t('Arguments must be valid JSON'));
+      await beginPkce(authChallenge);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : String(err));
+      setConnecting(false);
+    }
+  };
+
+  const handleBearerConnect = () => {
+    if (!authChallenge || !bearerToken.trim()) {
+      return;
+    }
+    void handleConnect(authChallenge.mcpEndpoint, authChallenge.selectedKey, bearerToken.trim());
+  };
+
+  React.useEffect(() => {
+    const params = new URLSearchParams(window.location.search);
+    const oauthError = params.get('error');
+    if (oauthError) {
+      const description = params.get('error_description') || oauthError;
+      setError(description);
+      clearPkceStorage();
+      window.history.replaceState({}, '', window.location.pathname);
+      return;
+    }
+    const code = params.get('code');
+    const state = params.get('state');
+    if (code && state) {
+      stashOauthCallback(code, state);
+      window.history.replaceState({}, '', window.location.pathname);
+    }
+    if (!peekOauthCallback()) {
+      return;
+    }
+    if (!takeOauthExchangeLock()) {
+      return;
+    }
+    setConnecting(true);
+    void (async () => {
+      try {
+        const result = await completePkce();
+        setSelectedKey(result.selectedKey);
+        await runSession(result.mcpEndpoint, result.accessToken);
+        setAuthMode('oidc');
+      } catch (err) {
+        clientRef.current = null;
+        setSessionId(null);
+        setConnected(false);
+        setError(err instanceof Error ? err.message : String(err));
+      } finally {
+        setConnecting(false);
+      }
+    })();
+    // OAuth callback state is consumed only once when the inspector mounts.
+  }, []);
+
+  const handleCall = async (
+    toolName: string,
+    args: Record<string, unknown>,
+    metadata?: Record<string, unknown>,
+  ) => {
+    const client = clientRef.current;
+    if (!client) {
       return;
     }
     setError('');
     setSessionExpired(false);
     setCalling(true);
-    setCallResult(null);
+    setCallExchange(null);
+    const startedAt = Date.now();
     try {
-      const result = await client.toolsCall(selectedTool, parsedArgs);
-      setCallResult(result);
+      const exchange = metadata
+        ? await client.toolsCallWithDetails(toolName, args, metadata)
+        : await client.toolsCallWithDetails(toolName, args);
+      setCallExchange(exchange);
+      setStats((current) => ({
+        calls: current.calls + 1,
+        succeeded: current.succeeded + (exchange.result.isError ? 0 : 1),
+        failed: current.failed + (exchange.result.isError ? 1 : 0),
+        totalDurationMs: current.totalDurationMs + exchange.durationMs,
+      }));
     } catch (err) {
+      setStats((current) => ({
+        ...current,
+        calls: current.calls + 1,
+        failed: current.failed + 1,
+        totalDurationMs: current.totalDurationMs + (Date.now() - startedAt),
+      }));
       if (err instanceof MCPSessionExpiredError) {
         setSessionExpired(true);
       } else {
@@ -151,92 +289,144 @@ const MCPInspectorPage: React.FC = () => {
     }
   };
 
+  const handleRefreshTools = async () => {
+    const client = clientRef.current;
+    if (!client) {
+      return;
+    }
+    setRefreshingTools(true);
+    setError('');
+    setSessionExpired(false);
+    try {
+      const listed = await client.toolsList();
+      setTools(listed.tools ?? []);
+    } catch (err) {
+      if (err instanceof MCPSessionExpiredError) {
+        setSessionExpired(true);
+      } else {
+        setError(err instanceof Error ? err.message : String(err));
+      }
+    } finally {
+      setRefreshingTools(false);
+    }
+  };
+
   return (
     <>
       <Helmet>
         <title>{t('MCP Inspector')}</title>
       </Helmet>
       <NamespaceBar />
-      <PageSection>
+      <PageSection className="kuadrant-mcp-inspector-page">
         <Stack hasGutter>
           <StackItem>
             <Title headingLevel="h1">{t('MCP Inspector')}</Title>
-            <Content component="p">
-              {t(
-                'Throwaway proof-of-concept: the browser speaks MCP Streamable HTTP directly to a gateway endpoint. Calls are cross-origin.',
-              )}
-            </Content>
-            <Content component="small">
-              {t('Browser origin')}: <code>{origin}</code>
-            </Content>
           </StackItem>
 
           <StackItem>
-            <Form>
-              <FormGroup label={t('MCP gateway extension')} fieldId="mcp-inspector-extension">
-                <FormSelect
-                  id="mcp-inspector-extension"
-                  value={selectedKey}
-                  onChange={(_event, value) => setSelectedKey(value)}
-                  aria-label={t('Select an MCP gateway extension')}
-                  isDisabled={!extensionsLoaded}
-                >
-                  <FormSelectOption
-                    value=""
-                    label={
-                      !extensionsLoaded ? t('Loading extensions...') : t('Select an extension...')
-                    }
-                    isPlaceholder
-                  />
-                  {list.map((ext) => {
-                    const reachable = !!ext.status?.mcpEndpoint && isReady(ext);
-                    const name = `${ext.metadata?.name} (${ext.metadata?.namespace})`;
-                    return (
-                      <FormSelectOption
-                        key={extKey(ext)}
-                        value={extKey(ext)}
-                        label={reachable ? name : `${name} — ${t('not reachable')}`}
-                        isDisabled={!reachable}
+            <Card className="kuadrant-mcp-inspector-page__connection-card">
+              <CardBody>
+                <Grid>
+                  <GridItem md={4} className="kuadrant-mcp-inspector-page__connection-segment">
+                    <Form>
+                      <FormGroup label={t('Gateway')} fieldId="mcp-inspector-extension">
+                        <FormSelect
+                          id="mcp-inspector-extension"
+                          value={selectedKey}
+                          onChange={handleGatewayChange}
+                          aria-label={t('Select an MCP gateway extension')}
+                          isDisabled={!extensionsLoaded}
+                        >
+                          <FormSelectOption
+                            value=""
+                            label={
+                              !extensionsLoaded
+                                ? t('Loading extensions...')
+                                : t('Select an extension...')
+                            }
+                            isPlaceholder
+                          />
+                          {list.map((ext) => {
+                            const reachable = !!ext.status?.mcpEndpoint && isReady(ext);
+                            const name = `${ext.metadata?.name} (${ext.metadata?.namespace})`;
+                            return (
+                              <FormSelectOption
+                                key={extKey(ext)}
+                                value={extKey(ext)}
+                                label={reachable ? name : `${name} — ${t('not reachable')}`}
+                                isDisabled={!reachable}
+                              />
+                            );
+                          })}
+                        </FormSelect>
+                      </FormGroup>
+                    </Form>
+                    {endpoint && (
+                      <Content component="small" className="kuadrant-mcp-inspector-page__endpoint">
+                        {endpoint}
+                      </Content>
+                    )}
+                  </GridItem>
+                  <GridItem md={4} className="kuadrant-mcp-inspector-page__connection-segment">
+                    <Content component="p" className="kuadrant-mcp-inspector-page__segment-title">
+                      {t('Connection')}
+                    </Content>
+                    <div className="kuadrant-mcp-inspector-page__connection-status">
+                      <span
+                        className={`kuadrant-mcp-inspector-page__status-dot ${
+                          connected ? 'is-connected' : ''
+                        }`}
                       />
-                    );
-                  })}
-                </FormSelect>
-              </FormGroup>
-
-              <FormGroup label={t('Resolved endpoint')} fieldId="mcp-inspector-endpoint">
-                <Content component="small">
-                  <code>{endpoint || t('none')}</code>
-                </Content>
-              </FormGroup>
-
-              <FormGroup label={t('Bearer token (optional)')} fieldId="mcp-inspector-token">
-                <TextInput
-                  id="mcp-inspector-token"
-                  type="password"
-                  value={token}
-                  onChange={(_event, value) => setToken(value)}
-                  placeholder={t('Held in memory only')}
-                />
-              </FormGroup>
-
-              <StackItem>
-                <Button
-                  variant="primary"
-                  onClick={handleConnect}
-                  isDisabled={!endpoint || connecting}
-                  isLoading={connecting}
-                >
-                  {t('Connect + list tools')}
-                </Button>
-              </StackItem>
-            </Form>
+                      <span>
+                        {connecting
+                          ? t('Connecting...')
+                          : connected
+                          ? t('Connected')
+                          : t('No connection')}
+                      </span>
+                      {connected && (
+                        <span>
+                          {authMode === 'none' ? t('No authentication') : t('Authenticated')}
+                        </span>
+                      )}
+                    </div>
+                    {sessionId && (
+                      <Content
+                        component="small"
+                        className="kuadrant-mcp-inspector-page__session-id"
+                      >
+                        {t('Session ID')}: <code>{sessionId}</code>
+                      </Content>
+                    )}
+                  </GridItem>
+                  <GridItem md={4} className="kuadrant-mcp-inspector-page__connection-segment">
+                    <Content component="p" className="kuadrant-mcp-inspector-page__segment-title">
+                      {t('Status')}
+                    </Content>
+                    <div className="kuadrant-mcp-inspector-page__session-status">
+                      <span>
+                        {stats.calls} {stats.calls === 1 ? t('request') : t('requests')}
+                      </span>
+                      <span>
+                        {sessionExpired ? 1 : 0} {t('warnings')}
+                      </span>
+                      <span>
+                        {stats.failed} {t('errors')}
+                      </span>
+                    </div>
+                  </GridItem>
+                </Grid>
+              </CardBody>
+            </Card>
           </StackItem>
 
-          {sessionId && (
+          {!selectedKey && extensionsLoaded && (
             <StackItem>
-              <Content component="small">
-                {t('Session ID')}: <code>{sessionId}</code>
-              </Content>
+              <EmptyState headingLevel="h2" titleText={t('No connection')}>
+                <EmptyStateBody>
+                  {t('Connect to a Gateway to view the MCP server tools available.')}
+                </EmptyStateBody>
+              </EmptyState>
             </StackItem>
           )}
 
@@ -256,73 +446,114 @@ const MCPInspectorPage: React.FC = () => {
             </StackItem>
           )}
 
-          {initResult && (
+          {connected && (
             <StackItem>
-              <Title headingLevel="h2">{t('initialize')}</Title>
-              <pre style={preStyle}>{JSON.stringify(initResult, null, 2)}</pre>
-            </StackItem>
-          )}
-
-          {toolsResult && (
-            <StackItem>
-              <Title headingLevel="h2">{t('tools/list')}</Title>
-              <pre style={preStyle}>{JSON.stringify(toolsResult, null, 2)}</pre>
-            </StackItem>
-          )}
-
-          {tools.length > 0 && (
-            <>
-              <StackItem>
-                <Divider />
-              </StackItem>
-              <StackItem>
-                <Title headingLevel="h2">{t('Call a tool')}</Title>
-                <Form>
-                  <FormGroup label={t('Tool')} fieldId="mcp-inspector-tool">
-                    <FormSelect
-                      id="mcp-inspector-tool"
-                      value={selectedTool}
-                      onChange={(_event, value) => setSelectedTool(value)}
-                      aria-label={t('Select a tool')}
-                    >
-                      <FormSelectOption value="" label={t('Select a tool...')} isPlaceholder />
-                      {tools.map((tool) => (
-                        <FormSelectOption key={tool.name} value={tool.name} label={tool.name} />
-                      ))}
-                    </FormSelect>
-                  </FormGroup>
-                  <FormGroup label={t('Arguments (JSON)')} fieldId="mcp-inspector-args">
-                    <TextArea
-                      id="mcp-inspector-args"
-                      value={argsText}
-                      onChange={(_event, value) => setArgsText(value)}
-                      rows={6}
-                      aria-label={t('Tool call arguments as JSON')}
+              <Tabs
+                activeKey={activeSection}
+                onSelect={(_event, key) => setActiveSection(key)}
+                aria-label={t('MCP inspector sections')}
+              >
+                <Tab eventKey={0} title={<TabTitleText>{t('Tools')}</TabTitleText>} />
+                <Tab eventKey={1} title={<TabTitleText>{t('Prompts')}</TabTitleText>} />
+                <Tab eventKey={2} title={<TabTitleText>{t('Logs')}</TabTitleText>} />
+              </Tabs>
+              {activeSection === 0 && (
+                <Stack hasGutter className="kuadrant-mcp-inspector-page__section">
+                  <StackItem>
+                    <Alert
+                      variant="warning"
+                      isInline
+                      isPlain
+                      title={t(
+                        'Running tools executes live server-side code and can change your infrastructure.',
+                      )}
+                      className="kuadrant-mcp-inspector-page__tool-warning"
                     />
-                  </FormGroup>
+                  </StackItem>
                   <StackItem>
-                    <Button
-                      variant="secondary"
-                      onClick={handleCall}
-                      isDisabled={!selectedTool || calling}
-                      isLoading={calling}
-                    >
-                      {t('Call')}
-                    </Button>
+                    <Grid hasGutter>
+                      <GridItem md={6}>
+                        <MCPToolWorkspace
+                          tools={tools}
+                          isRunning={calling}
+                          isRefreshing={refreshingTools}
+                          onRefresh={handleRefreshTools}
+                          onRun={handleCall}
+                        />
+                      </GridItem>
+                      <GridItem md={6}>
+                        <MCPInspectorOutput exchange={callExchange} />
+                      </GridItem>
+                    </Grid>
                   </StackItem>
-                </Form>
-              </StackItem>
-            </>
-          )}
-
-          {callResult && (
-            <StackItem>
-              <Title headingLevel="h2">{t('tools/call result')}</Title>
-              <pre style={preStyle}>{JSON.stringify(callResult, null, 2)}</pre>
+                </Stack>
+              )}
+              {activeSection === 1 && (
+                <EmptyState headingLevel="h2" titleText={t('Prompts')}>
+                  <EmptyStateBody>{t('Prompt inspection is not available yet.')}</EmptyStateBody>
+                </EmptyState>
+              )}
+              {activeSection === 2 && (
+                <EmptyState headingLevel="h2" titleText={t('Logs')}>
+                  <EmptyStateBody>{t('Session logs are not available yet.')}</EmptyStateBody>
+                </EmptyState>
+              )}
             </StackItem>
           )}
         </Stack>
       </PageSection>
+      <Modal
+        isOpen={!!authChallenge}
+        onClose={() => setAuthChallenge(null)}
+        variant={ModalVariant.small}
+        aria-labelledby="mcp-inspector-auth-title"
+      >
+        <ModalHeader title={t('Authentication required')} labelId="mcp-inspector-auth-title" />
+        <ModalBody>
+          <Stack hasGutter>
+            <StackItem>
+              <Content component="p">
+                {t(
+                  'This MCP gateway requires authentication. Sign in with OIDC or provide a bearer token.',
+                )}
+              </Content>
+            </StackItem>
+            <StackItem>
+              <Button variant="primary" onClick={handleOidcSignIn} isLoading={connecting}>
+                {t('Sign in with OIDC')}
+              </Button>
+            </StackItem>
+            <StackItem>
+              <Divider />
+            </StackItem>
+            <StackItem>
+              <FormGroup label={t('Bearer token')} fieldId="mcp-inspector-bearer-token">
+                <TextInput
+                  id="mcp-inspector-bearer-token"
+                  type="password"
+                  value={bearerToken}
+                  onChange={(_event, value) => setBearerToken(value)}
+                  aria-label={t('Bearer token')}
+                  placeholder={t('Held in memory only')}
+                />
+              </FormGroup>
+            </StackItem>
+          </Stack>
+        </ModalBody>
+        <ModalFooter>
+          <Button
+            variant="secondary"
+            onClick={handleBearerConnect}
+            isDisabled={!bearerToken.trim() || connecting}
+            isLoading={connecting}
+          >
+            {t('Connect with bearer token')}
+          </Button>
+          <Button variant="link" onClick={() => setAuthChallenge(null)}>
+            {t('Cancel')}
+          </Button>
+        </ModalFooter>
+      </Modal>
     </>
   );
 };
diff --git a/src/components/mcp/MCPToolWorkspace.tsx b/src/components/mcp/MCPToolWorkspace.tsx
new file mode 100644
index 00000000..fa14c6d4
--- /dev/null
+++ b/src/components/mcp/MCPToolWorkspace.tsx
@@ -0,0 +1,450 @@
+import * as React from 'react';
+import { useTranslation } from 'react-i18next';
+import {
+  Alert,
+  Button,
+  Card,
+  CardBody,
+  CardHeader,
+  CardTitle,
+  Checkbox,
+  Content,
+  Form,
+  FormGroup,
+  FormSelect,
+  FormSelectOption,
+  Label,
+  LabelGroup,
+  SearchInput,
+  TextArea,
+  TextInput,
+  Title,
+  Tooltip,
+} from '@patternfly/react-core';
+import { SyncAltIcon } from '@patternfly/react-icons';
+import { MCPTool } from '../../utils/mcp/client';
+
+interface JsonSchema {
+  type?: string | string[];
+  title?: string;
+  description?: string;
+  default?: unknown;
+  enum?: unknown[];
+  properties?: Record<string, JsonSchema>;
+  required?: string[];
+  items?: JsonSchema;
+}
+
+interface MCPToolWorkspaceProps {
+  tools: MCPTool[];
+  isRunning: boolean;
+  isRefreshing: boolean;
+  onRefresh: () => Promise<void>;
+  onRun: (
+    name: string,
+    args: Record<string, unknown>,
+    metadata?: Record<string, unknown>,
+  ) => Promise<void>;
+}
+
+type FieldValues = Record<string, string | boolean>;
+interface MetadataRow {
+  id: number;
+  key: string;
+  value: string;
+}
+
+const humanize = (value: string): string => {
+  const words = value.replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/[-_]+/g, ' ');
+  return words.charAt(0).toUpperCase() + words.slice(1);
+};
+
+const schemaType = (schema: JsonSchema): string => {
+  if (Array.isArray(schema.type)) {
+    return schema.type.find((type) => type !== 'null') ?? 'string';
+  }
+  return schema.type ?? 'string';
+};
+
+const initialValues = (tool: MCPTool): FieldValues => {
+  const properties = (tool.inputSchema as JsonSchema | undefined)?.properties ?? {};
+  return Object.entries(properties).reduce<FieldValues>((values, [name, schema]) => {
+    if (schema.default !== undefined) {
+      values[name] =
+        typeof schema.default === 'boolean'
+          ? schema.default
+          : typeof schema.default === 'string'
+          ? schema.default
+          : JSON.stringify(schema.default, null, 2);
+    } else {
+      values[name] = schemaType(schema) === 'boolean' ? false : '';
+    }
+    return values;
+  }, {});
+};
+
+const annotationLabels = (tool: MCPTool): string[] => {
+  const annotations = tool.annotations ?? {};
+  return [
+    annotations.readOnlyHint ? 'Read only' : '',
+    annotations.destructiveHint ? 'Destructive' : '',
+    annotations.idempotentHint ? 'Idempotent' : '',
+    annotations.openWorldHint ? 'Open world' : '',
+  ].filter(Boolean);
+};
+
+const translatedAnnotation = (annotation: string, t: (key: string) => string): string => {
+  switch (annotation) {
+    case 'Read only':
+      return t('Read only');
+    case 'Destructive':
+      return t('Destructive');
+    case 'Idempotent':
+      return t('Idempotent');
+    case 'Open world':
+      return t('Open world');
+    default:
+      return annotation;
+  }
+};
+
+const MCPToolWorkspace: React.FC<MCPToolWorkspaceProps> = ({
+  tools,
+  isRunning,
+  isRefreshing,
+  onRefresh,
+  onRun,
+}) => {
+  const { t } = useTranslation('plugin__kuadrant-console-plugin');
+  const [search, setSearch] = React.useState('');
+  const [selectedToolName, setSelectedToolName] = React.useState('');
+  const [values, setValues] = React.useState<FieldValues>({});
+  const [fieldErrors, setFieldErrors] = React.useState<Record<string, string>>({});
+  const [validationMessage, setValidationMessage] = React.useState('');
+  const [metadataRows, setMetadataRows] = React.useState<MetadataRow[]>([]);
+  const nextMetadataId = React.useRef(1);
+
+  const selectedTool = tools.find((tool) => tool.name === selectedToolName);
+  const filteredTools = tools.filter((tool) => {
+    const term = search.trim().toLowerCase();
+    return (
+      !term ||
+      tool.name.toLowerCase().includes(term) ||
+      (tool.description ?? '').toLowerCase().includes(term)
+    );
+  });
+
+  const selectTool = (tool: MCPTool) => {
+    setSelectedToolName(tool.name);
+    setValues(initialValues(tool));
+    setFieldErrors({});
+    setValidationMessage('');
+    setMetadataRows([]);
+  };
+
+  const validate = (): Record<string, unknown> | null => {
+    if (!selectedTool) {
+      return null;
+    }
+    const inputSchema = (selectedTool.inputSchema ?? {}) as JsonSchema;
+    const properties = inputSchema.properties ?? {};
+    const required = new Set(inputSchema.required ?? []);
+    const errors: Record<string, string> = {};
+    const args: Record<string, unknown> = {};
+
+    Object.entries(properties).forEach(([name, propertySchema]) => {
+      const value = values[name];
+      const label = propertySchema.title || humanize(name);
+      const type = schemaType(propertySchema);
+      const isEmpty = value === undefined || value === '';
+
+      if (required.has(name) && isEmpty) {
+        errors[name] = t('{{field}} is required', { field: label });
+        return;
+      }
+      if (isEmpty) {
+        return;
+      }
+
+      if (type === 'number' || type === 'integer') {
+        const parsed = Number(value);
+        if (!Number.isFinite(parsed) || (type === 'integer' && !Number.isInteger(parsed))) {
+          errors[name] =
+            type === 'integer'
+              ? t('{{field}} must be an integer', { field: label })
+              : t('{{field}} must be a number', { field: label });
+          return;
+        }
+        args[name] = parsed;
+        return;
+      }
+
+      if (type === 'object' || type === 'array') {
+        try {
+          const parsed = JSON.parse(String(value));
+          if (
+            (type === 'array' && !Array.isArray(parsed)) ||
+            (type === 'object' && (Array.isArray(parsed) || typeof parsed !== 'object'))
+          ) {
+            throw new Error('wrong JSON type');
+          }
+          args[name] = parsed;
+        } catch {
+          errors[name] = t('{{field}} must be valid JSON', { field: label });
+        }
+        return;
+      }
+
+      args[name] = value;
+    });
+
+    setFieldErrors(errors);
+    if (Object.keys(errors).length > 0) {
+      setValidationMessage('');
+      return null;
+    }
+    setValidationMessage(t('Input is valid'));
+    return args;
+  };
+
+  const run = async () => {
+    const args = validate();
+    if (args && selectedTool) {
+      const metadata = metadataRows.reduce<Record<string, unknown>>((result, row) => {
+        if (row.key.trim()) {
+          result[row.key.trim()] = row.value;
+        }
+        return result;
+      }, {});
+      if (Object.keys(metadata).length > 0) {
+        await onRun(selectedTool.name, args, metadata);
+      } else {
+        await onRun(selectedTool.name, args);
+      }
+    }
+  };
+
+  const addMetadata = () => {
+    setMetadataRows((current) => [
+      ...current,
+      { id: nextMetadataId.current++, key: '', value: '' },
+    ]);
+  };
+
+  const updateMetadata = (id: number, field: 'key' | 'value', value: string) => {
+    setMetadataRows((current) =>
+      current.map((row) => (row.id === id ? { ...row, [field]: value } : row)),
+    );
+  };
+
+  const renderField = (name: string, propertySchema: JsonSchema) => {
+    const type = schemaType(propertySchema);
+    const label = propertySchema.title || humanize(name);
+    const id = `mcp-tool-argument-${name}`;
+    const value = values[name] ?? '';
+    const setValue = (next: string | boolean) => {
+      setValues((current) => ({ ...current, [name]: next }));
+      setFieldErrors((current) => ({ ...current, [name]: '' }));
+      setValidationMessage('');
+    };
+
+    if (propertySchema.enum) {
+      return (
+        <FormSelect
+          id={id}
+          value={String(value)}
+          onChange={(_event, next) => setValue(next)}
+          aria-label={label}
+        >
+          <FormSelectOption value="" label={t('Select a value...')} isPlaceholder />
+          {propertySchema.enum.map((option) => (
+            <FormSelectOption key={String(option)} value={String(option)} label={String(option)} />
+          ))}
+        </FormSelect>
+      );
+    }
+
+    if (type === 'boolean') {
+      return (
+        <Checkbox
+          id={id}
+          label={propertySchema.description || label}
+          isChecked={Boolean(value)}
+          onChange={(_event, checked) => setValue(checked)}
+          aria-label={label}
+        />
+      );
+    }
+
+    if (type === 'object' || type === 'array') {
+      return (
+        <TextArea
+          id={id}
+          value={String(value)}
+          onChange={(_event, next) => setValue(next)}
+          aria-label={label}
+          placeholder={type === 'array' ? '[]' : '{}'}
+          rows={4}
+          validated={fieldErrors[name] ? 'error' : 'default'}
+        />
+      );
+    }
+
+    return (
+      <TextInput
+        id={id}
+        type={type === 'number' || type === 'integer' ? 'number' : 'text'}
+        value={String(value)}
+        onChange={(_event, next) => setValue(next)}
+        aria-label={label}
+        validated={fieldErrors[name] ? 'error' : 'default'}
+      />
+    );
+  };
+
+  const inputSchema = (selectedTool?.inputSchema ?? {}) as JsonSchema;
+  const properties = inputSchema.properties ?? {};
+  const required = new Set(inputSchema.required ?? []);
+
+  return (
+    <Card isFullHeight className="kuadrant-mcp-inspector-page__workspace">
+      <CardHeader
+        actions={{
+          actions: (
+            <Tooltip content={t('Refresh tools')}>
+              <Button
+                variant="plain"
+                icon={<SyncAltIcon aria-hidden="true" />}
+                onClick={() => void onRefresh()}
+                isLoading={isRefreshing}
+                isDisabled={isRefreshing}
+                aria-label={t('Refresh tools')}
+              />
+            </Tooltip>
+          ),
+        }}
+      >
+        <CardTitle>{t('Select a tool')}</CardTitle>
+      </CardHeader>
+      <CardBody>
+        <SearchInput
+          value={search}
+          onChange={(_event, value) => setSearch(value)}
+          onClear={() => setSearch('')}
+          aria-label={t('Search tools')}
+          placeholder={t('Search tools')}
+        />
+        <div className="kuadrant-mcp-inspector-page__tool-list">
+          {filteredTools.map((tool) => (
+            <Button
+              key={tool.name}
+              variant="plain"
+              className={
+                tool.name === selectedToolName
+                  ? 'kuadrant-mcp-inspector-page__tool is-selected'
+                  : 'kuadrant-mcp-inspector-page__tool'
+              }
+              onClick={() => selectTool(tool)}
+            >
+              {tool.name}
+            </Button>
+          ))}
+          {filteredTools.length === 0 && <Content component="small">{t('No tools found')}</Content>}
+        </div>
+        {selectedTool ? (
+          <div className="kuadrant-mcp-inspector-page__selected-tool">
+            <Title headingLevel="h2">{selectedTool.name}</Title>
+            <Content component="p">{selectedTool.description || t('No description')}</Content>
+            <Content component="small">
+              {t('Server')}: {selectedTool.name.split('_')[0] || t('Unknown')}
+            </Content>
+            {annotationLabels(selectedTool).length > 0 && (
+              <LabelGroup className="kuadrant-mcp-inspector-page__annotations">
+                {annotationLabels(selectedTool).map((annotation) => (
+                  <Label key={annotation}>{translatedAnnotation(annotation, t)}</Label>
+                ))}
+              </LabelGroup>
+            )}
+            <Form className="kuadrant-mcp-inspector-page__tool-form">
+              {Object.entries(properties).map(([name, propertySchema]) => {
+                const label = propertySchema.title || humanize(name);
+                return (
+                  <FormGroup
+                    key={name}
+                    label={label}
+                    fieldId={`mcp-tool-argument-${name}`}
+                    isRequired={required.has(name)}
+                  >
+                    {renderField(name, propertySchema)}
+                    {propertySchema.description && schemaType(propertySchema) !== 'boolean' && (
+                      <Content component="small">{propertySchema.description}</Content>
+                    )}
+                    {fieldErrors[name] && (
+                      <Content
+                        component="small"
+                        className="kuadrant-mcp-inspector-page__field-error"
+                      >
+                        {fieldErrors[name]}
+                      </Content>
+                    )}
+                  </FormGroup>
+                );
+              })}
+              <div className="kuadrant-mcp-inspector-page__metadata">
+                <div className="kuadrant-mcp-inspector-page__metadata-heading">
+                  <Title headingLevel="h3">{t('Metadata')}</Title>
+                  <Button variant="link" onClick={addMetadata} isInline>
+                    {t('Add metadata')}
+                  </Button>
+                </div>
+                <Content component="small">
+                  {t('Optional key-value metadata is sent with the MCP tool call.')}
+                </Content>
+                {metadataRows.map((row) => (
+                  <div key={row.id} className="kuadrant-mcp-inspector-page__metadata-row">
+                    <TextInput
+                      value={row.key}
+                      onChange={(_event, value) => updateMetadata(row.id, 'key', value)}
+                      aria-label={t('Metadata key')}
+                      placeholder={t('Key')}
+                    />
+                    <TextInput
+                      value={row.value}
+                      onChange={(_event, value) => updateMetadata(row.id, 'value', value)}
+                      aria-label={t('Metadata value')}
+                      placeholder={t('Value')}
+                    />
+                    <Button
+                      variant="link"
+                      onClick={() =>
+                        setMetadataRows((current) => current.filter((item) => item.id !== row.id))
+                      }
+                      aria-label={t('Remove metadata')}
+                    >
+                      {t('Remove')}
+                    </Button>
+                  </div>
+                ))}
+              </div>
+              {validationMessage && (
+                <Alert variant="success" isInline isPlain title={validationMessage} />
+              )}
+              <div className="kuadrant-mcp-inspector-page__actions">
+                <Button variant="secondary" onClick={validate}>
+                  {t('Validate only')}
+                </Button>
+                <Button variant="primary" onClick={run} isLoading={isRunning}>
+                  {t('Run tool')}
+                </Button>
+              </div>
+            </Form>
+          </div>
+        ) : (
+          <Content component="p">{t('Select a tool to inspect and run it.')}</Content>
+        )}
+      </CardBody>
+    </Card>
+  );
+};
+
+export default MCPToolWorkspace;
diff --git a/src/utils/mcp/client.test.ts b/src/utils/mcp/client.test.ts
new file mode 100644
index 00000000..d8387064
--- /dev/null
+++ b/src/utils/mcp/client.test.ts
@@ -0,0 +1,73 @@
+import { MCPClient } from './client';
+
+const jsonResponse = (body: unknown, status = 200, statusText = 'OK') =>
+  ({
+    ok: status >= 200 && status < 300,
+    status,
+    statusText,
+    headers: {
+      get: (name: string) => (name.toLowerCase() === 'content-type' ? 'application/json' : null),
+    },
+    text: jest.fn().mockResolvedValue(JSON.stringify(body)),
+  } as unknown as Response);
+
+describe('MCPClient', () => {
+  beforeEach(() => {
+    global.fetch = jest.fn();
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  it('returns request, response, HTTP status and duration for a tool call', async () => {
+    (global.fetch as jest.Mock).mockResolvedValue(
+      jsonResponse({
+        jsonrpc: '2.0',
+        id: 1,
+        result: { content: [{ type: 'text', text: 'Hello, Ada!' }] },
+      }),
+    );
+    jest.spyOn(Date, 'now').mockReturnValueOnce(100).mockReturnValueOnce(145);
+    const client = new MCPClient('https://mcp.example.test/mcp', { token: 'test-token' });
+
+    const exchange = await client.toolsCallWithDetails(
+      'toystore_greet',
+      { name: 'Ada' },
+      { traceId: 'trace-1' },
+    );
+
+    expect(exchange).toEqual({
+      result: { content: [{ type: 'text', text: 'Hello, Ada!' }] },
+      request: {
+        jsonrpc: '2.0',
+        id: 1,
+        method: 'tools/call',
+        params: {
+          name: 'toystore_greet',
+          arguments: { name: 'Ada' },
+          _meta: { traceId: 'trace-1' },
+        },
+      },
+      response: {
+        jsonrpc: '2.0',
+        id: 1,
+        result: { content: [{ type: 'text', text: 'Hello, Ada!' }] },
+      },
+      status: 200,
+      statusText: 'OK',
+      durationMs: 45,
+    });
+    expect(global.fetch).toHaveBeenCalledWith(
+      'https://mcp.example.test/mcp',
+      expect.objectContaining({
+        method: 'POST',
+        credentials: 'omit',
+        headers: expect.objectContaining({
+          Authorization: 'Bearer test-token',
+          'MCP-Protocol-Version': '2025-11-25',
+        }),
+      }),
+    );
+  });
+});
diff --git a/src/utils/mcp/client.ts b/src/utils/mcp/client.ts
index 2d7ede60..ce562e9a 100644
--- a/src/utils/mcp/client.ts
+++ b/src/utils/mcp/client.ts
@@ -1,8 +1,8 @@
-// tiny dependency-free mcp streamable http client (poc).
-// speaks json-rpc 2.0 over a single endpoint, handles json + sse responses,
-// and keeps the session id in memory only (caller holds it in react state).
+// Dependency-free MCP Streamable HTTP client. It speaks JSON-RPC 2.0 over a
+// single endpoint, handles JSON and SSE responses, and keeps the session ID in
+// memory only (the caller holds it in React state).
 
-const MCP_PROTOCOL_VERSION = '2025-03-26';
+export const MCP_PROTOCOL_VERSION = '2025-11-25';
 
 export interface JsonRpcError {
   code: number;
@@ -10,13 +10,20 @@ export interface JsonRpcError {
   data?: unknown;
 }
 
-interface JsonRpcResponse<T> {
+export interface JsonRpcResponse<T> {
   jsonrpc: '2.0';
   id: number | string | null;
   result?: T;
   error?: JsonRpcError;
 }
 
+export interface JsonRpcRequest extends Record<string, unknown> {
+  jsonrpc: '2.0';
+  id: number | string;
+  method: string;
+  params: Record<string, unknown>;
+}
+
 export interface InitializeResult {
   protocolVersion: string;
   capabilities?: Record<string, unknown>;
@@ -29,6 +36,15 @@ export interface MCPTool {
   name: string;
   description?: string;
   inputSchema?: Record<string, unknown>;
+  annotations?: {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+    [key: string]: unknown;
+  };
+  _meta?: Record<string, unknown>;
   [key: string]: unknown;
 }
 
@@ -44,6 +60,15 @@ export interface ToolsCallResult {
   [key: string]: unknown;
 }
 
+export interface MCPCallExchange<T> {
+  result: T;
+  request: JsonRpcRequest;
+  response: JsonRpcResponse<T>;
+  status: number;
+  statusText: string;
+  durationMs: number;
+}
+
 // json-rpc level error (server returned an error object).
 export class MCPRpcError extends Error {
   code: number;
@@ -66,6 +91,16 @@ export class MCPHttpError extends Error {
   }
 }
 
+// initialize 401: caller starts PKCE from WWW-Authenticate (RFC 9728).
+export class MCPUnauthorizedError extends MCPHttpError {
+  wwwAuthenticate: string | null;
+  constructor(wwwAuthenticate: string | null) {
+    super(401, 'initialize failed (http 401)');
+    this.name = 'MCPUnauthorizedError';
+    this.wwwAuthenticate = wwwAuthenticate;
+  }
+}
+
 // distinct so the page can prompt "session expired, reconnect".
 export class MCPSessionExpiredError extends Error {
   constructor() {
@@ -106,6 +141,9 @@ export class MCPClient {
       },
     });
     if (!res.ok) {
+      if (res.status === 401) {
+        throw new MCPUnauthorizedError(res.headers.get('WWW-Authenticate'));
+      }
       throw new MCPHttpError(res.status, `initialize failed (http ${res.status})`);
     }
     const headerSession = res.headers.get('Mcp-Session-Id');
@@ -130,7 +168,40 @@ export class MCPClient {
   }
 
   async toolsCall(name: string, args: Record<string, unknown>): Promise<ToolsCallResult> {
-    return this.call<ToolsCallResult>('tools/call', { name, arguments: args });
+    return (await this.toolsCallWithDetails(name, args)).result;
+  }
+
+  async toolsCallWithDetails(
+    name: string,
+    args: Record<string, unknown>,
+    metadata?: Record<string, unknown>,
+  ): Promise<MCPCallExchange<ToolsCallResult>> {
+    const request: JsonRpcRequest = {
+      jsonrpc: '2.0',
+      id: this.nextId++,
+      method: 'tools/call',
+      params: {
+        name,
+        arguments: args,
+        ...(metadata && Object.keys(metadata).length > 0 ? { _meta: metadata } : {}),
+      },
+    };
+    const startedAt = Date.now();
+    const res = await this.post(request);
+    if (!res.ok) {
+      throw this.httpErrorFor(res.status, 'tools/call failed');
+    }
+    const response = await parseRpcMessage<ToolsCallResult>(res);
+    const durationMs = Date.now() - startedAt;
+    throwOnRpcError(response);
+    return {
+      result: response.result as ToolsCallResult,
+      request,
+      response,
+      status: res.status,
+      statusText: res.statusText,
+      durationMs,
+    };
   }
 
   private async call<T>(method: string, params: Record<string, unknown>): Promise<T> {
diff --git a/src/utils/mcp/oauth.test.ts b/src/utils/mcp/oauth.test.ts
new file mode 100644
index 00000000..e59c58f5
--- /dev/null
+++ b/src/utils/mcp/oauth.test.ts
@@ -0,0 +1,144 @@
+import {
+  authorizationServerMetadataUrl,
+  discoverOAuthConfiguration,
+  parseResourceMetadataUrl,
+  pluginRedirectUri,
+  resourceMetadataFallbackUrl,
+} from './oauth';
+
+const jsonResponse = (body: unknown, status = 200) =>
+  ({
+    ok: status >= 200 && status < 300,
+    status,
+    json: jest.fn().mockResolvedValue(body),
+    text: jest.fn().mockResolvedValue(JSON.stringify(body)),
+  } as unknown as Response);
+
+const resourceMetadataParam = 'resource' + '_metadata';
+
+describe('parseResourceMetadataUrl', () => {
+  it('extracts a quoted URI from a WWW-Authenticate Bearer challenge', () => {
+    const header = `Bearer ${resourceMetadataParam}="https://mcp.example/.well-known/oauth-protected-resource/mcp", scope="openid"`;
+    expect(parseResourceMetadataUrl(header)).toBe(
+      'https://mcp.example/.well-known/oauth-protected-resource/mcp',
+    );
+  });
+
+  it('extracts an unquoted URI (Authorino / mcp-gateway)', () => {
+    const header = `Bearer ${resourceMetadataParam}=https://mcp.example/.well-known/oauth-protected-resource/mcp`;
+    expect(parseResourceMetadataUrl(header)).toBe(
+      'https://mcp.example/.well-known/oauth-protected-resource/mcp',
+    );
+  });
+
+  it('returns null when the header is missing or has no resource metadata param', () => {
+    expect(parseResourceMetadataUrl(null)).toBeNull();
+    expect(parseResourceMetadataUrl('Bearer realm="mcp"')).toBeNull();
+  });
+});
+
+describe('authorizationServerMetadataUrl', () => {
+  it('builds the RFC 8414 path for a Keycloak realm issuer', () => {
+    expect(authorizationServerMetadataUrl('https://keycloak.example/realms/mcp')).toBe(
+      'https://keycloak.example/.well-known/oauth-authorization-server/realms/mcp',
+    );
+  });
+
+  it('strips a trailing slash on the issuer path', () => {
+    expect(authorizationServerMetadataUrl('https://keycloak.example/realms/mcp/')).toBe(
+      'https://keycloak.example/.well-known/oauth-authorization-server/realms/mcp',
+    );
+  });
+});
+
+describe('resourceMetadataFallbackUrl', () => {
+  it('inserts /.well-known/oauth-protected-resource before the resource path', () => {
+    expect(resourceMetadataFallbackUrl('https://mcp.example/mcp')).toBe(
+      'https://mcp.example/.well-known/oauth-protected-resource/mcp',
+    );
+  });
+});
+
+describe('pluginRedirectUri', () => {
+  it('is the inspector page on the current origin', () => {
+    expect(pluginRedirectUri()).toBe(`${window.location.origin}/mcp-inspector`);
+  });
+});
+
+describe('discoverOAuthConfiguration', () => {
+  beforeEach(() => {
+    global.fetch = jest.fn();
+  });
+
+  it('discovers metadata and dynamically registers a public PKCE client', async () => {
+    (global.fetch as jest.Mock)
+      .mockResolvedValueOnce(
+        jsonResponse({
+          resource: 'https://mcp.example/mcp',
+          authorization_servers: ['https://id.example/realms/mcp'],
+        }),
+      )
+      .mockResolvedValueOnce(
+        jsonResponse({
+          authorization_endpoint: 'https://id.example/realms/mcp/protocol/openid-connect/auth',
+          token_endpoint: 'https://id.example/realms/mcp/protocol/openid-connect/token',
+          registration_endpoint:
+            'https://id.example/realms/mcp/clients-registrations/openid-connect',
+          scopes_supported: ['openid', 'profile', 'email'],
+        }),
+      )
+      .mockResolvedValueOnce(jsonResponse({ client_id: 'dynamic-console-client' }, 201));
+
+    const configuration = await discoverOAuthConfiguration({
+      mcpEndpoint: 'https://mcp.example/mcp',
+      wwwAuthenticate:
+        'Bearer resource_metadata="https://mcp.example/.well-known/oauth-protected-resource/mcp"',
+      redirectUri: 'https://console.example/mcp-inspector',
+    });
+
+    expect(configuration).toEqual({
+      authorizationEndpoint: 'https://id.example/realms/mcp/protocol/openid-connect/auth',
+      tokenEndpoint: 'https://id.example/realms/mcp/protocol/openid-connect/token',
+      clientId: 'dynamic-console-client',
+      resource: 'https://mcp.example/mcp',
+      scopes: 'openid profile email',
+    });
+    expect(global.fetch).toHaveBeenLastCalledWith(
+      'https://id.example/realms/mcp/clients-registrations/openid-connect',
+      expect.objectContaining({
+        method: 'POST',
+        credentials: 'omit',
+        body: JSON.stringify({
+          client_name: 'Kuadrant Console MCP Inspector',
+          redirect_uris: ['https://console.example/mcp-inspector'],
+          token_endpoint_auth_method: 'none',
+          grant_types: ['authorization_code'],
+          response_types: ['code'],
+        }),
+      }),
+    );
+  });
+
+  it('explains when OIDC cannot register a browser client', async () => {
+    (global.fetch as jest.Mock)
+      .mockResolvedValueOnce(
+        jsonResponse({ authorization_servers: ['https://id.example/realms/mcp'] }),
+      )
+      .mockResolvedValueOnce(
+        jsonResponse({
+          authorization_endpoint: 'https://id.example/auth',
+          token_endpoint: 'https://id.example/token',
+        }),
+      );
+
+    await expect(
+      discoverOAuthConfiguration({
+        mcpEndpoint: 'https://mcp.example/mcp',
+        wwwAuthenticate: null,
+        redirectUri: 'https://console.example/mcp-inspector',
+      }),
+    ).rejects.toThrow(
+      'OIDC sign-in is unavailable because the authorization server does not support dynamic client registration. Use a bearer token instead.',
+    );
+  });
+});
diff --git a/src/utils/mcp/oauth.ts b/src/utils/mcp/oauth.ts
new file mode 100644
index 00000000..eb365926
--- /dev/null
+++ b/src/utils/mcp/oauth.ts
@@ -0,0 +1,301 @@
+// Browser-only OAuth 2.1 authorization-code flow with PKCE. Discovery follows
+// the MCP protected-resource challenge and client registration is dynamic.
+
+import { MCP_PROTOCOL_VERSION } from './client';
+
+export const PKCE_SCOPES = ['openid', 'profile', 'email'];
+
+const PENDING_KEY = 'kuadrant-mcp-inspector-pkce';
+const CALLBACK_KEY = 'kuadrant-mcp-inspector-pkce-callback';
+const EXCHANGE_LOCK_KEY = 'kuadrant-mcp-inspector-pkce-lock';
+
+export interface PkcePending {
+  verifier: string;
+  state: string;
+  selectedKey: string;
+  mcpEndpoint: string;
+  tokenEndpoint: string;
+  clientId: string;
+  redirectUri: string;
+  resource: string;
+}
+
+export interface ResourceMetadata {
+  resource?: string;
+  authorization_servers?: string[];
+}
+
+export interface AuthorizationServerMetadata {
+  authorization_endpoint?: string;
+  token_endpoint?: string;
+  registration_endpoint?: string;
+  scopes_supported?: string[];
+}
+
+export interface OAuthConfiguration {
+  authorizationEndpoint: string;
+  tokenEndpoint: string;
+  clientId: string;
+  resource: string;
+  scopes: string;
+}
+
+export function parseResourceMetadataUrl(wwwAuthenticate: string | null): string | null {
+  if (!wwwAuthenticate) {
+    return null;
+  }
+  const quoted = wwwAuthenticate.match(/resource_metadata="([^"]+)"/i);
+  if (quoted?.[1]) {
+    return quoted[1];
+  }
+  // Authorino/mcp-gateway can emit an unquoted URI.
+  const unquoted = wwwAuthenticate.match(/resource_metadata=([^\s,]+)/i);
+  return unquoted?.[1] ?? null;
+}
+
+export function authorizationServerMetadataUrl(issuer: string): string {
+  const url = new URL(issuer);
+  const path = url.pathname.replace(/\/$/, '');
+  return `${url.origin}/.well-known/oauth-authorization-server${path}`;
+}
+
+export function resourceMetadataFallbackUrl(mcpEndpoint: string): string {
+  const url = new URL(mcpEndpoint);
+  return `${url.origin}/.well-known/oauth-protected-resource${url.pathname}`;
+}
+
+export function pluginRedirectUri(): string {
+  return `${window.location.origin}/mcp-inspector`;
+}
+
+export function stashOauthCallback(code: string, state: string): void {
+  sessionStorage.setItem(CALLBACK_KEY, JSON.stringify({ code, state }));
+}
+
+export function peekOauthCallback(): { code: string; state: string } | null {
+  const raw = sessionStorage.getItem(CALLBACK_KEY);
+  if (!raw) {
+    return null;
+  }
+  try {
+    const parsed = JSON.parse(raw) as { code?: string; state?: string };
+    if (parsed.code && parsed.state) {
+      return { code: parsed.code, state: parsed.state };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+// one-tab lock so React Strict Mode does not exchange the same code twice.
+export function takeOauthExchangeLock(): boolean {
+  if (sessionStorage.getItem(EXCHANGE_LOCK_KEY)) {
+    return false;
+  }
+  sessionStorage.setItem(EXCHANGE_LOCK_KEY, '1');
+  return true;
+}
+
+export function clearPkceStorage(): void {
+  sessionStorage.removeItem(CALLBACK_KEY);
+  sessionStorage.removeItem(PENDING_KEY);
+  sessionStorage.removeItem(EXCHANGE_LOCK_KEY);
+}
+
+export async function discoverOAuthConfiguration(opts: {
+  mcpEndpoint: string;
+  wwwAuthenticate: string | null;
+  redirectUri: string;
+}): Promise<OAuthConfiguration> {
+  const metadataUrl =
+    parseResourceMetadataUrl(opts.wwwAuthenticate) ?? resourceMetadataFallbackUrl(opts.mcpEndpoint);
+  const resourceMeta = await fetchJson<ResourceMetadata>(metadataUrl);
+  const issuer = resourceMeta.authorization_servers?.[0];
+  if (!issuer) {
+    throw new Error('MCP resource metadata does not advertise an authorization server.');
+  }
+
+  const asMeta = await fetchJson<AuthorizationServerMetadata>(
+    authorizationServerMetadataUrl(issuer),
+  );
+  if (!asMeta.authorization_endpoint || !asMeta.token_endpoint) {
+    throw new Error('Authorization server metadata is missing authorization or token endpoints.');
+  }
+  if (!asMeta.registration_endpoint) {
+    throw new Error(
+      'OIDC sign-in is unavailable because the authorization server does not support dynamic client registration. Use a bearer token instead.',
+    );
+  }
+
+  const registration = await registerClient(asMeta.registration_endpoint, opts.redirectUri);
+  const supportedScopes = asMeta.scopes_supported;
+  const scopes = supportedScopes
+    ? PKCE_SCOPES.filter((scope) => supportedScopes.includes(scope)).join(' ')
+    : PKCE_SCOPES.join(' ');
+
+  return {
+    authorizationEndpoint: asMeta.authorization_endpoint,
+    tokenEndpoint: asMeta.token_endpoint,
+    clientId: registration.client_id,
+    resource: resourceMeta.resource || opts.mcpEndpoint,
+    scopes,
+  };
+}
+
+export async function beginPkce(opts: {
+  mcpEndpoint: string;
+  selectedKey: string;
+  wwwAuthenticate: string | null;
+}): Promise<void> {
+  const redirectUri = pluginRedirectUri();
+  const configuration = await discoverOAuthConfiguration({
+    mcpEndpoint: opts.mcpEndpoint,
+    wwwAuthenticate: opts.wwwAuthenticate,
+    redirectUri,
+  });
+
+  const verifier = randomUrlSafe(32);
+  const state = randomUrlSafe(16);
+  const challenge = await pkceChallenge(verifier);
+
+  const pending: PkcePending = {
+    verifier,
+    state,
+    selectedKey: opts.selectedKey,
+    mcpEndpoint: opts.mcpEndpoint,
+    tokenEndpoint: configuration.tokenEndpoint,
+    clientId: configuration.clientId,
+    redirectUri,
+    resource: configuration.resource,
+  };
+  sessionStorage.setItem(PENDING_KEY, JSON.stringify(pending));
+
+  const auth = new URL(configuration.authorizationEndpoint);
+  auth.searchParams.set('response_type', 'code');
+  auth.searchParams.set('client_id', configuration.clientId);
+  auth.searchParams.set('redirect_uri', redirectUri);
+  auth.searchParams.set('state', state);
+  auth.searchParams.set('code_challenge', challenge);
+  auth.searchParams.set('code_challenge_method', 'S256');
+  if (configuration.scopes) {
+    auth.searchParams.set('scope', configuration.scopes);
+  }
+  auth.searchParams.set('resource', configuration.resource);
+
+  window.location.assign(auth.toString());
+}
+
+export async function completePkce(): Promise<{
+  accessToken: string;
+  selectedKey: string;
+  mcpEndpoint: string;
+}> {
+  const callback = peekOauthCallback();
+  const pendingRaw = sessionStorage.getItem(PENDING_KEY);
+  if (!callback || !pendingRaw) {
+    throw new Error('OAuth callback is missing PKCE state');
+  }
+  const pending = JSON.parse(pendingRaw) as PkcePending;
+  if (callback.state !== pending.state) {
+    clearPkceStorage();
+    throw new Error('OAuth state mismatch');
+  }
+
+  const body = new URLSearchParams({
+    grant_type: 'authorization_code',
+    code: callback.code,
+    redirect_uri: pending.redirectUri,
+    client_id: pending.clientId,
+    code_verifier: pending.verifier,
+    resource: pending.resource,
+  });
+
+  const res = await fetch(pending.tokenEndpoint, {
+    method: 'POST',
+    credentials: 'omit',
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/x-www-form-urlencoded',
+    },
+    body,
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    clearPkceStorage();
+    throw new Error(`token exchange failed (http ${res.status}): ${text}`);
+  }
+  const token = (await res.json()) as { access_token?: string };
+  if (!token.access_token) {
+    clearPkceStorage();
+    throw new Error('token response has no access_token');
+  }
+  const { selectedKey, mcpEndpoint } = pending;
+  clearPkceStorage();
+  return { accessToken: token.access_token, selectedKey, mcpEndpoint };
+}
+
+async function fetchJson<T>(url: string): Promise<T> {
+  const res = await fetch(url, {
+    method: 'GET',
+    credentials: 'omit',
+    headers: {
+      Accept: 'application/json',
+      'MCP-Protocol-Version': MCP_PROTOCOL_VERSION,
+    },
+  });
+  if (!res.ok) {
+    throw new Error(`GET ${url} failed (http ${res.status})`);
+  }
+  return res.json() as Promise<T>;
+}
+
+async function registerClient(
+  registrationEndpoint: string,
+  redirectUri: string,
+): Promise<{ client_id: string }> {
+  const body = {
+    client_name: 'Kuadrant Console MCP Inspector',
+    redirect_uris: [redirectUri],
+    token_endpoint_auth_method: 'none',
+    grant_types: ['authorization_code'],
+    response_types: ['code'],
+  };
+  const res = await fetch(registrationEndpoint, {
+    method: 'POST',
+    credentials: 'omit',
+    headers: {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Dynamic OAuth client registration failed (http ${res.status}): ${text}`);
+  }
+  const registration = (await res.json()) as { client_id?: string };
+  if (!registration.client_id) {
+    throw new Error('Dynamic OAuth client registration returned no client_id.');
+  }
+  return { client_id: registration.client_id };
+}
+
+function randomUrlSafe(byteLength: number): string {
+  const bytes = new Uint8Array(byteLength);
+  crypto.getRandomValues(bytes);
+  return base64UrlEncode(bytes);
+}
+
+async function pkceChallenge(verifier: string): Promise<string> {
+  const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(verifier));
+  return base64UrlEncode(new Uint8Array(digest));
+}
+
+function base64UrlEncode(bytes: Uint8Array): string {
+  let binary = '';
+  bytes.forEach((b) => {
+    binary += String.fromCharCode(b);
+  });
+  return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}

From 59a89853ce8cba0cdc640accd1f05ed325cea153 Mon Sep 17 00:00:00 2001
From: Jason Madigan <jason@jasonmadigan.com>
Date: Tue, 25 Aug 2026 12:24:47 +0100
Subject: [PATCH 3/4] feat: proxy MCP inspector through plugin backend

Signed-off-by: Jason Madigan <jason@jasonmadigan.com>
---
 .dockerignore                                 |   7 +
 Dockerfile                                    |  28 +-
 Makefile                                      |   5 +-
 README.md                                     |  28 +-
 .../templates/configmap.yaml                  |  32 --
 .../templates/consoleplugin.yaml              |  13 +-
 .../templates/deployment.yaml                 |  15 +-
 cmd/plugin-server/main.go                     | 379 ++++++++++++++++++
 cmd/plugin-server/main_test.go                |  87 ++++
 docs/mcp-inspector.md                         |  34 +-
 docs/overview.md                              |   2 +-
 e2e/README.md                                 |  17 +-
 e2e/tests/mcp-inspector.spec.ts               |   8 +
 entrypoint.sh                                 |  13 -
 go.mod                                        |   3 +
 install.yaml                                  | 110 ++---
 .../en/plugin__kuadrant-console-plugin.json   |   3 +-
 scripts/sync-console-plugin-proxy.sh          |  27 ++
 src/components/mcp/MCPInspectorPage.test.tsx  |  11 +-
 src/components/mcp/MCPInspectorPage.tsx       |  99 +----
 src/utils/mcp/client.test.ts                  |  23 +-
 src/utils/mcp/client.ts                       |  35 +-
 start-local.sh                                |   6 +-
 23 files changed, 706 insertions(+), 279 deletions(-)
 create mode 100644 .dockerignore
 delete mode 100644 charts/openshift-console-plugin/templates/configmap.yaml
 create mode 100644 cmd/plugin-server/main.go
 create mode 100644 cmd/plugin-server/main_test.go
 delete mode 100755 entrypoint.sh
 create mode 100644 go.mod
 create mode 100755 scripts/sync-console-plugin-proxy.sh

diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 00000000..c6c4ee23
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,7 @@
+.git
+.claude
+node_modules
+dist
+coverage
+playwright-report
+test-results
diff --git a/Dockerfile b/Dockerfile
index 6ad0c888..d24f2b77 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -16,6 +16,7 @@ RUN yarn config set --home enableGlobalCache true
 WORKDIR /usr/src/app
 
 COPY package.json yarn.lock .yarnrc.yml ./
+COPY .yarn/patches ./.yarn/patches
 RUN YARN_ENABLE_SCRIPTS=false yarn install --immutable
 
 COPY . .
@@ -26,23 +27,26 @@ RUN test -f ./dist/plugin-manifest.json && \
     test -d ./dist/locales && \
     echo "All required files are present."
 
-# Stage 2: Runtime image on target architecture
-FROM registry.access.redhat.com/ubi9/ubi-minimal:latest
+# Stage 2: Build the small asset server and MCP relay on the target architecture.
+FROM golang:1.24 AS go-builder
+
+WORKDIR /usr/src/app
+COPY go.mod ./
+COPY cmd/plugin-server ./cmd/plugin-server
+RUN CGO_ENABLED=0 go build -trimpath -ldflags="-s -w" -o /plugin-server ./cmd/plugin-server
 
-RUN microdnf module enable nginx:1.24 -y && \
-    microdnf install -y nginx && \
-    microdnf clean all
+# Stage 3: Runtime image on target architecture
+FROM registry.access.redhat.com/ubi9/ubi-minimal:latest
 
-RUN mkdir -p /var/cache/nginx /var/log/nginx /run && \
-    chown -R root:0 /var/cache/nginx /var/log/nginx /run /usr/share/nginx/html && \
-    chmod -R g+rwX /var/cache/nginx /var/log/nginx /run && \
-    chmod -R g+rX /usr/share/nginx/html
+RUN mkdir -p /usr/share/kuadrant-console-plugin && \
+    chown -R root:0 /usr/share/kuadrant-console-plugin && \
+    chmod -R g+rX /usr/share/kuadrant-console-plugin
 
-COPY --from=builder /usr/src/app/dist/ /usr/share/nginx/html/
-COPY entrypoint.sh /usr/share/nginx/html/entrypoint.sh
+COPY --from=builder /usr/src/app/dist/ /usr/share/kuadrant-console-plugin/
+COPY --from=go-builder /plugin-server /usr/local/bin/plugin-server
 
 ARG QUAY_IMAGE_EXPIRY="never"
 LABEL quay.expires-after=${QUAY_IMAGE_EXPIRY}
 
 USER 1001
-ENTRYPOINT ["/usr/share/nginx/html/entrypoint.sh"]
+ENTRYPOINT ["/usr/local/bin/plugin-server"]
diff --git a/Makefile b/Makefile
index 17a051da..218f45e3 100644
--- a/Makefile
+++ b/Makefile
@@ -1,7 +1,10 @@
-.PHONY: oinc oinc-teardown
+.PHONY: oinc oinc-sync-plugin-proxy oinc-teardown
 
 oinc:
 	./start-local.sh
 
+oinc-sync-plugin-proxy:
+	./scripts/sync-console-plugin-proxy.sh
+
 oinc-teardown:
 	./scripts/teardown.sh
diff --git a/README.md b/README.md
index 3288d51a..6b281a40 100644
--- a/README.md
+++ b/README.md
@@ -7,6 +7,7 @@ Based on https://github.com/openshift/console-plugin-template
 ## Screenshots
 
 ![Overview](docs/images/overview.gif)
+
 ## Running
 
 - Target a running OCP with `oc login`
@@ -46,11 +47,20 @@ Prerequisites: [oinc](https://github.com/jasonmadigan/oinc), [kubectl](https://k
 
 ```bash
 make oinc          # create cluster + start plugin dev server with hot reload
+make oinc-sync-plugin-proxy # sync an operator-reconciled backend proxy into dev Console
 make oinc-teardown # tear it all down
 ```
 
 Console runs at http://localhost:9000, plugin at http://localhost:9001. If the cluster already exists, `make oinc` skips setup and just starts the plugin server.
 
+OINC runs Console as a standalone development container, so it does not have
+the OpenShift Console operator to consume `ConsolePlugin.spec.proxy`. After a
+development Kuadrant Operator reconciles a plugin backend proxy, run
+`make oinc-sync-plugin-proxy` once (and again if the backend Service changes).
+This target is development glue only; the Kuadrant Operator remains the source
+of truth for production plugin resources. Set `OINC_BIN` if the development
+OINC binary is not on `PATH`.
+
 ### Option 3: Docker + VSCode Remote Container
 
 Make sure the
@@ -88,9 +98,15 @@ docker buildx build --platform linux/amd64,linux/arm64 -t quay.io/kuadrant/conso
 2. Run the image:
 
 ```bash
-docker run -it --rm -d -p 9001:80 quay.io/kuadrant/console-plugin:latest
+docker run -it --rm -d -p 9001:9443 \
+  -e KUBERNETES_INSECURE_SKIP_TLS_VERIFY=true \
+  quay.io/kuadrant/console-plugin:latest
 ```
 
+The development flag lets the image serve its static assets outside a pod,
+where the Kubernetes service-account CA is not mounted. Do not use it for an
+in-cluster deployment.
+
 NOTE: If you have a Mac with Apple silicon, you will need to add the flag
 `--platform=linux/amd64` when building the image to target the correct platform
 to run in-cluster.
@@ -176,13 +192,14 @@ Update `settings.json` (File > Preferences > Settings):
 ```json
 "editor.formatOnSave": true
 ```
+
 ## Version matrix
 
 | kuadrant-console-plugin version | PatternFly version | Openshift console version | Dynamic Plugin SDK |
-|---------------------------------|--------------------|---------------------------|--------------------|
-|         v0.0.3 - v0.0.18        |          5         |          v4.17.x          |       v1.6.0       |
-|                TBD              |          5         |          v4.18.x          |       v1.8.0       |
-|                TBD              |          6         |          v4.19.x          |         TBD        |
+| ------------------------------- | ------------------ | ------------------------- | ------------------ |
+| v0.0.3 - v0.0.18                | 5                  | v4.17.x                   | v1.6.0             |
+| TBD                             | 5                  | v4.18.x                   | v1.8.0             |
+| TBD                             | 6                  | v4.19.x                   | TBD                |
 
 Openshift console is configured to share modules with its dynamic plugins (console plugins). For more information on versions and changes to the shared modules, please see the shared modules [documentation](https://www.npmjs.com/package/@openshift-console/dynamic-plugin-sdk?activeTab=readme)
 
@@ -236,4 +253,3 @@ Deletions are confirmed interactively in batches of 25.
 ## Troubleshooting
 
 For troubleshooting common issues, please see [TROUBLESHOOTING.md](TROUBLESHOOTING.md).
-
diff --git a/charts/openshift-console-plugin/templates/configmap.yaml b/charts/openshift-console-plugin/templates/configmap.yaml
deleted file mode 100644
index 41ce0f2c..00000000
--- a/charts/openshift-console-plugin/templates/configmap.yaml
+++ /dev/null
@@ -1,32 +0,0 @@
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: {{ template "openshift-console-plugin.name" . }}
-  namespace: {{ .Release.Namespace }}
-  labels:
-    {{- include "openshift-console-plugin.labels" . | nindent 4 }}
-data:
-  nginx.conf: |
-    error_log /dev/stdout info;
-    events {}
-    http {
-      access_log         /dev/stdout;
-      include            /etc/nginx/mime.types;
-      default_type       application/octet-stream;
-      keepalive_timeout  65;
-      server {
-        listen              {{ .Values.plugin.port }} ssl;
-        listen              [::]:{{ .Values.plugin.port }} ssl;
-        ssl_certificate     /var/cert/tls.crt;
-        ssl_certificate_key /var/cert/tls.key;
-
-        location / {
-          root                /usr/share/nginx/html;
-        }
-
-        # Serve config.js from /tmp
-        location /config.js {
-          root /tmp;
-        }
-      }
-    }
diff --git a/charts/openshift-console-plugin/templates/consoleplugin.yaml b/charts/openshift-console-plugin/templates/consoleplugin.yaml
index c70aa50e..86ef29a9 100644
--- a/charts/openshift-console-plugin/templates/consoleplugin.yaml
+++ b/charts/openshift-console-plugin/templates/consoleplugin.yaml
@@ -7,7 +7,7 @@ metadata:
     {{- include "openshift-console-plugin.labels" . | nindent 4 }}
 spec:
   displayName: {{ default (printf "%s Plugin" (include "openshift-console-plugin.name" .)) .Values.plugin.description }}
-  i18n: 
+  i18n:
     loadType: Preload
   backend:
     type: Service
@@ -15,4 +15,13 @@ spec:
       name: {{ template "openshift-console-plugin.name" . }}
       namespace: {{ .Release.Namespace }}
       port: {{ .Values.plugin.port }}
-      basePath: {{ .Values.plugin.basePath }}
\ No newline at end of file
+      basePath: {{ .Values.plugin.basePath }}
+  proxy:
+    - alias: backend
+      authorization: UserToken
+      endpoint:
+        type: Service
+        service:
+          name: {{ template "openshift-console-plugin.name" . }}
+          namespace: {{ .Release.Namespace }}
+          port: {{ .Values.plugin.port }}
diff --git a/charts/openshift-console-plugin/templates/deployment.yaml b/charts/openshift-console-plugin/templates/deployment.yaml
index 46b3a47e..a2234821 100644
--- a/charts/openshift-console-plugin/templates/deployment.yaml
+++ b/charts/openshift-console-plugin/templates/deployment.yaml
@@ -20,7 +20,8 @@ spec:
         - name: {{ template "openshift-console-plugin.name" . }}
           image: {{ required "Plugin image must be specified!" .Values.plugin.image }}
           ports:
-            - containerPort: {{ .Values.plugin.port }}
+            - name: https
+              containerPort: {{ .Values.plugin.port }}
               protocol: TCP
           imagePullPolicy: {{ .Values.plugin.imagePullPolicy }}
           env:
@@ -30,6 +31,10 @@ spec:
               value: {{ .Values.plugin.topologyConfigMapNamespace | default "kuadrant-system" | quote }}
             - name: METRICS_WORKLOAD_SUFFIX
               value: {{ .Values.plugin.metricsWorkloadSuffix | default "-openshift-default" | quote }}
+            - name: TLS_CERTIFICATE_FILE
+              value: /var/cert/tls.crt
+            - name: TLS_KEY_FILE
+              value: /var/cert/tls.key
           {{- if and (.Values.plugin.securityContext.enabled) (.Values.plugin.containerSecurityContext) }}
           securityContext: {{ tpl (toYaml (omit .Values.plugin.containerSecurityContext "enabled")) $ | nindent 12 }}
           {{- end }}
@@ -39,19 +44,11 @@ spec:
             - name: {{ template "openshift-console-plugin.certificateSecret" . }}
               readOnly: true
               mountPath: /var/cert
-            - name: nginx-conf
-              readOnly: true
-              mountPath: /etc/nginx/nginx.conf
-              subPath: nginx.conf
       volumes:
         - name: {{ template "openshift-console-plugin.certificateSecret" . }}
           secret:
             secretName: {{ template "openshift-console-plugin.certificateSecret" . }}
             defaultMode: 420
-        - name: nginx-conf
-          configMap:
-            name: {{ template "openshift-console-plugin.name" . }}
-            defaultMode: 420
       restartPolicy: Always
       dnsPolicy: ClusterFirst
       {{- if and (.Values.plugin.securityContext.enabled) (.Values.plugin.podSecurityContext) }}
diff --git a/cmd/plugin-server/main.go b/cmd/plugin-server/main.go
new file mode 100644
index 00000000..b74e1f77
--- /dev/null
+++ b/cmd/plugin-server/main.go
@@ -0,0 +1,379 @@
+package main
+
+import (
+	"context"
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"log/slog"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"os/signal"
+	"path/filepath"
+	"strings"
+	"syscall"
+	"time"
+)
+
+const (
+	mcpProxyPrefix         = "/api/mcp/v1/gateways/"
+	mcpAuthorizationHeader = "X-Kuadrant-MCP-Authorization"
+	maxMCPRequestBytes     = 1024 * 1024
+)
+
+type config struct {
+	listenAddress         string
+	devListenAddress      string
+	staticDirectory       string
+	tlsCertificateFile    string
+	tlsKeyFile            string
+	kubernetesAPIURL      string
+	kubernetesCAFile      string
+	kubernetesSkipVerify  bool
+	upstreamSkipVerify    bool
+	upstreamDialAddress   string
+	allowInsecureMCPAuth  bool
+	requestTimeout        time.Duration
+	topologyConfigMapName string
+	topologyNamespace     string
+	metricsWorkloadSuffix string
+}
+
+type server struct {
+	config         config
+	kubernetesHTTP *http.Client
+	upstreamHTTP   *http.Client
+	logger         *slog.Logger
+}
+
+type mcpGatewayExtension struct {
+	Status struct {
+		Conditions []struct {
+			Type   string `json:"type"`
+			Status string `json:"status"`
+		} `json:"conditions"`
+		MCPEndpoint string `json:"mcpEndpoint"`
+	} `json:"status"`
+}
+
+type kubernetesStatus struct {
+	Message string `json:"message"`
+}
+
+type rpcEnvelope struct {
+	Method string `json:"method"`
+}
+
+func main() {
+	cfg, err := loadConfig()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+
+	logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))
+	backend, err := newServer(cfg, logger)
+	if err != nil {
+		logger.Error("configure server", "error", err)
+		os.Exit(1)
+	}
+
+	handler := backend.routes()
+	servers := []*http.Server{{
+		Addr:              cfg.listenAddress,
+		Handler:           handler,
+		ReadHeaderTimeout: 10 * time.Second,
+	}}
+	if cfg.devListenAddress != "" {
+		servers = append(servers, &http.Server{
+			Addr:              cfg.devListenAddress,
+			Handler:           handler,
+			ReadHeaderTimeout: 10 * time.Second,
+		})
+	}
+
+	ctx, stop := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)
+	defer stop()
+	for index, httpServer := range servers {
+		isTLS := index == 0 && cfg.tlsCertificateFile != "" && cfg.tlsKeyFile != ""
+		go func() {
+			logger.Info("server listening", "address", httpServer.Addr, "tls", isTLS)
+			var serveErr error
+			if isTLS {
+				serveErr = httpServer.ListenAndServeTLS(cfg.tlsCertificateFile, cfg.tlsKeyFile)
+			} else {
+				serveErr = httpServer.ListenAndServe()
+			}
+			if serveErr != nil && !errors.Is(serveErr, http.ErrServerClosed) {
+				logger.Error("server stopped", "error", serveErr)
+				stop()
+			}
+		}()
+	}
+
+	<-ctx.Done()
+	shutdownContext, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+	for _, httpServer := range servers {
+		if err := httpServer.Shutdown(shutdownContext); err != nil {
+			logger.Error("server shutdown", "error", err)
+		}
+	}
+}
+
+func loadConfig() (config, error) {
+	requestTimeout, err := time.ParseDuration(env("MCP_PROXY_REQUEST_TIMEOUT", "2m"))
+	if err != nil {
+		return config{}, fmt.Errorf("parse MCP_PROXY_REQUEST_TIMEOUT: %w", err)
+	}
+	return config{
+		listenAddress:         env("LISTEN_ADDRESS", ":9443"),
+		devListenAddress:      os.Getenv("DEV_LISTEN_ADDRESS"),
+		staticDirectory:       env("STATIC_DIRECTORY", "/usr/share/kuadrant-console-plugin"),
+		tlsCertificateFile:    os.Getenv("TLS_CERTIFICATE_FILE"),
+		tlsKeyFile:            os.Getenv("TLS_KEY_FILE"),
+		kubernetesAPIURL:      env("KUBERNETES_API_URL", "https://kubernetes.default.svc"),
+		kubernetesCAFile:      env("KUBERNETES_CA_FILE", "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt"),
+		kubernetesSkipVerify:  envBool("KUBERNETES_INSECURE_SKIP_TLS_VERIFY"),
+		upstreamSkipVerify:    envBool("MCP_PROXY_INSECURE_SKIP_TLS_VERIFY"),
+		upstreamDialAddress:   os.Getenv("MCP_PROXY_DIAL_ADDRESS"),
+		allowInsecureMCPAuth:  envBool("MCP_PROXY_ALLOW_INSECURE_AUTH"),
+		requestTimeout:        requestTimeout,
+		topologyConfigMapName: env("TOPOLOGY_CONFIGMAP_NAME", "topology"),
+		topologyNamespace:     env("TOPOLOGY_CONFIGMAP_NAMESPACE", "kuadrant-system"),
+		metricsWorkloadSuffix: env("METRICS_WORKLOAD_SUFFIX", "-openshift-default"),
+	}, nil
+}
+
+func newServer(cfg config, logger *slog.Logger) (*server, error) {
+	kubernetesTLS := &tls.Config{MinVersion: tls.VersionTLS12, InsecureSkipVerify: cfg.kubernetesSkipVerify} // #nosec G402 -- explicit development option
+	if !cfg.kubernetesSkipVerify {
+		caPEM, err := os.ReadFile(cfg.kubernetesCAFile)
+		if err != nil {
+			return nil, fmt.Errorf("read Kubernetes CA: %w", err)
+		}
+		roots, err := x509.SystemCertPool()
+		if err != nil || roots == nil {
+			roots = x509.NewCertPool()
+		}
+		if !roots.AppendCertsFromPEM(caPEM) {
+			return nil, errors.New("Kubernetes CA file contains no certificates")
+		}
+		kubernetesTLS.RootCAs = roots
+	}
+
+	upstreamTransport := http.DefaultTransport.(*http.Transport).Clone()
+	upstreamTransport.TLSClientConfig = &tls.Config{
+		MinVersion:         tls.VersionTLS12,
+		InsecureSkipVerify: cfg.upstreamSkipVerify, // #nosec G402 -- explicit development option
+	}
+	if cfg.upstreamDialAddress != "" {
+		dialer := &net.Dialer{Timeout: 30 * time.Second, KeepAlive: 30 * time.Second}
+		upstreamTransport.DialContext = func(ctx context.Context, _, _ string) (net.Conn, error) {
+			return dialer.DialContext(ctx, "tcp", cfg.upstreamDialAddress)
+		}
+	}
+
+	return &server{
+		config: cfg,
+		kubernetesHTTP: &http.Client{
+			Timeout: cfg.requestTimeout,
+			Transport: &http.Transport{
+				Proxy:           http.ProxyFromEnvironment,
+				TLSClientConfig: kubernetesTLS,
+			},
+			CheckRedirect: rejectRedirect,
+		},
+		upstreamHTTP: &http.Client{
+			Timeout:       cfg.requestTimeout,
+			Transport:     upstreamTransport,
+			CheckRedirect: rejectRedirect,
+		},
+		logger: logger,
+	}, nil
+}
+
+func (s *server) routes() http.Handler {
+	mux := http.NewServeMux()
+	mux.HandleFunc("GET /healthz", func(writer http.ResponseWriter, _ *http.Request) {
+		writer.WriteHeader(http.StatusOK)
+	})
+	mux.HandleFunc("GET /config.js", s.serveConfig)
+	mux.HandleFunc("POST "+mcpProxyPrefix+"{namespace}/{name}", s.proxyMCP)
+	mux.Handle("/", http.FileServer(http.Dir(s.config.staticDirectory)))
+	return mux
+}
+
+func (s *server) serveConfig(writer http.ResponseWriter, _ *http.Request) {
+	value := map[string]string{
+		"TOPOLOGY_CONFIGMAP_NAME":      s.config.topologyConfigMapName,
+		"TOPOLOGY_CONFIGMAP_NAMESPACE": s.config.topologyNamespace,
+		"METRICS_WORKLOAD_SUFFIX":      s.config.metricsWorkloadSuffix,
+	}
+	encoded, err := json.Marshal(value)
+	if err != nil {
+		http.Error(writer, "could not render config", http.StatusInternalServerError)
+		return
+	}
+	writer.Header().Set("Content-Type", "application/javascript; charset=utf-8")
+	_, _ = fmt.Fprintf(writer, "window.kuadrant_config = %s;\n", encoded)
+}
+
+func (s *server) proxyMCP(writer http.ResponseWriter, request *http.Request) {
+	userAuthorization := request.Header.Get("Authorization")
+	if !strings.HasPrefix(userAuthorization, "Bearer ") {
+		writeJSONError(writer, http.StatusUnauthorized, "OpenShift user authentication is required")
+		return
+	}
+
+	request.Body = http.MaxBytesReader(writer, request.Body, maxMCPRequestBytes)
+	body, err := io.ReadAll(request.Body)
+	if err != nil {
+		writeJSONError(writer, http.StatusRequestEntityTooLarge, "MCP request is too large")
+		return
+	}
+	var envelope rpcEnvelope
+	if err := json.Unmarshal(body, &envelope); err != nil || !allowedMCPMethod(envelope.Method) {
+		writeJSONError(writer, http.StatusBadRequest, "unsupported MCP request")
+		return
+	}
+
+	namespace := request.PathValue("namespace")
+	name := request.PathValue("name")
+	endpoint, status, err := s.resolveMCPEndpoint(request.Context(), namespace, name, userAuthorization)
+	if err != nil {
+		writeJSONError(writer, status, err.Error())
+		return
+	}
+
+	target, err := url.Parse(endpoint)
+	if err != nil || target.Host == "" || (target.Scheme != "http" && target.Scheme != "https") || target.User != nil || target.Fragment != "" {
+		writeJSONError(writer, http.StatusBadGateway, "MCPGatewayExtension has an invalid MCP endpoint")
+		return
+	}
+	mcpAuthorization := request.Header.Get(mcpAuthorizationHeader)
+	if mcpAuthorization != "" && target.Scheme != "https" && !s.config.allowInsecureMCPAuth {
+		writeJSONError(writer, http.StatusBadRequest, "refusing to send MCP credentials over an insecure connection")
+		return
+	}
+
+	upstreamRequest, err := http.NewRequestWithContext(request.Context(), http.MethodPost, target.String(), strings.NewReader(string(body)))
+	if err != nil {
+		writeJSONError(writer, http.StatusBadGateway, "could not create MCP request")
+		return
+	}
+	copyRequestHeader(request.Header, upstreamRequest.Header, "Content-Type")
+	copyRequestHeader(request.Header, upstreamRequest.Header, "Accept")
+	copyRequestHeader(request.Header, upstreamRequest.Header, "MCP-Protocol-Version")
+	copyRequestHeader(request.Header, upstreamRequest.Header, "Mcp-Session-Id")
+	if mcpAuthorization != "" {
+		upstreamRequest.Header.Set("Authorization", mcpAuthorization)
+	}
+
+	upstreamResponse, err := s.upstreamHTTP.Do(upstreamRequest)
+	if err != nil {
+		s.logger.Warn("MCP upstream request failed", "namespace", namespace, "name", name, "error", err)
+		writeJSONError(writer, http.StatusBadGateway, "MCP gateway request failed")
+		return
+	}
+	defer upstreamResponse.Body.Close()
+	for _, header := range []string{"Content-Type", "Mcp-Session-Id", "MCP-Protocol-Version", "WWW-Authenticate"} {
+		copyResponseHeader(upstreamResponse.Header, writer.Header(), header)
+	}
+	writer.WriteHeader(upstreamResponse.StatusCode)
+	_, _ = io.Copy(writer, upstreamResponse.Body)
+}
+
+func (s *server) resolveMCPEndpoint(ctx context.Context, namespace, name, authorization string) (string, int, error) {
+	baseURL, err := url.Parse(s.config.kubernetesAPIURL)
+	if err != nil {
+		return "", http.StatusInternalServerError, errors.New("Kubernetes API URL is invalid")
+	}
+	baseURL.Path = filepath.ToSlash(filepath.Join(baseURL.Path, "apis/mcp.kuadrant.io/v1/namespaces", namespace, "mcpgatewayextensions", name))
+	lookup, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL.String(), nil)
+	if err != nil {
+		return "", http.StatusInternalServerError, errors.New("could not create Kubernetes API request")
+	}
+	lookup.Header.Set("Authorization", authorization)
+	lookup.Header.Set("Accept", "application/json")
+
+	response, err := s.kubernetesHTTP.Do(lookup)
+	if err != nil {
+		s.logger.Error("Kubernetes API lookup failed", "error", err)
+		return "", http.StatusBadGateway, errors.New("could not resolve MCP gateway")
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusOK {
+		var status kubernetesStatus
+		_ = json.NewDecoder(io.LimitReader(response.Body, 64*1024)).Decode(&status)
+		message := status.Message
+		if message == "" {
+			message = "could not access MCPGatewayExtension"
+		}
+		return "", response.StatusCode, errors.New(message)
+	}
+
+	var extension mcpGatewayExtension
+	if err := json.NewDecoder(io.LimitReader(response.Body, 1024*1024)).Decode(&extension); err != nil {
+		return "", http.StatusBadGateway, errors.New("Kubernetes API returned an invalid MCPGatewayExtension")
+	}
+	ready := false
+	for _, condition := range extension.Status.Conditions {
+		if condition.Type == "Ready" && condition.Status == "True" {
+			ready = true
+			break
+		}
+	}
+	if !ready || extension.Status.MCPEndpoint == "" {
+		return "", http.StatusConflict, errors.New("MCPGatewayExtension is not ready")
+	}
+	return extension.Status.MCPEndpoint, http.StatusOK, nil
+}
+
+func allowedMCPMethod(method string) bool {
+	switch method {
+	case "initialize", "notifications/initialized", "tools/list", "tools/call":
+		return true
+	default:
+		return false
+	}
+}
+
+func copyRequestHeader(from, to http.Header, name string) {
+	if value := from.Get(name); value != "" {
+		to.Set(name, value)
+	}
+}
+
+func copyResponseHeader(from, to http.Header, name string) {
+	for _, value := range from.Values(name) {
+		to.Add(name, value)
+	}
+}
+
+func writeJSONError(writer http.ResponseWriter, status int, message string) {
+	writer.Header().Set("Content-Type", "application/json")
+	writer.WriteHeader(status)
+	_ = json.NewEncoder(writer).Encode(map[string]string{"error": message})
+}
+
+func rejectRedirect(_ *http.Request, _ []*http.Request) error {
+	return http.ErrUseLastResponse
+}
+
+func env(name, fallback string) string {
+	if value := os.Getenv(name); value != "" {
+		return value
+	}
+	return fallback
+}
+
+func envBool(name string) bool {
+	value := strings.ToLower(os.Getenv(name))
+	return value == "1" || value == "true" || value == "yes"
+}
diff --git a/cmd/plugin-server/main_test.go b/cmd/plugin-server/main_test.go
new file mode 100644
index 00000000..5f10da0a
--- /dev/null
+++ b/cmd/plugin-server/main_test.go
@@ -0,0 +1,87 @@
+package main
+
+import (
+	"encoding/json"
+	"io"
+	"log/slog"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestMCPProxyKeepsConsoleAndMCPAuthorizationSeparate(t *testing.T) {
+	var kubernetesAuthorization string
+	var upstreamAuthorization string
+
+	upstream := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
+		upstreamAuthorization = request.Header.Get("Authorization")
+		writer.Header().Set("Content-Type", "application/json")
+		writer.Header().Set("Mcp-Session-Id", "session-1")
+		_, _ = io.WriteString(writer, `{"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2025-11-25"}}`)
+	}))
+	defer upstream.Close()
+
+	kubernetes := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
+		kubernetesAuthorization = request.Header.Get("Authorization")
+		writer.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(writer).Encode(map[string]any{
+			"status": map[string]any{
+				"conditions":  []map[string]string{{"type": "Ready", "status": "True"}},
+				"mcpEndpoint": upstream.URL,
+			},
+		})
+	}))
+	defer kubernetes.Close()
+
+	backend, err := newServer(config{
+		kubernetesAPIURL:     kubernetes.URL,
+		kubernetesSkipVerify: true,
+		allowInsecureMCPAuth: true,
+		requestTimeout:       time.Second,
+	}, slog.New(slog.NewTextHandler(io.Discard, nil)))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	request := httptest.NewRequest(
+		http.MethodPost,
+		mcpProxyPrefix+"test-ns/test-extension",
+		strings.NewReader(`{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}`),
+	)
+	request.Header.Set("Authorization", "Bearer openshift-user-token")
+	request.Header.Set(mcpAuthorizationHeader, "Bearer mcp-gateway-token")
+	response := httptest.NewRecorder()
+
+	backend.routes().ServeHTTP(response, request)
+
+	if response.Code != http.StatusOK {
+		t.Fatalf("status = %d, body = %s", response.Code, response.Body.String())
+	}
+	if kubernetesAuthorization != "Bearer openshift-user-token" {
+		t.Fatalf("Kubernetes Authorization = %q", kubernetesAuthorization)
+	}
+	if upstreamAuthorization != "Bearer mcp-gateway-token" {
+		t.Fatalf("MCP upstream Authorization = %q", upstreamAuthorization)
+	}
+	if response.Header().Get("Mcp-Session-Id") != "session-1" {
+		t.Fatalf("MCP session header was not relayed")
+	}
+}
+
+func TestMCPProxyRequiresConsoleUserToken(t *testing.T) {
+	backend := &server{logger: slog.New(slog.NewTextHandler(io.Discard, nil))}
+	request := httptest.NewRequest(
+		http.MethodPost,
+		mcpProxyPrefix+"test-ns/test-extension",
+		strings.NewReader(`{"jsonrpc":"2.0","id":1,"method":"initialize","params":{}}`),
+	)
+	response := httptest.NewRecorder()
+
+	backend.routes().ServeHTTP(response, request)
+
+	if response.Code != http.StatusUnauthorized {
+		t.Fatalf("status = %d, want %d", response.Code, http.StatusUnauthorized)
+	}
+}
diff --git a/docs/mcp-inspector.md b/docs/mcp-inspector.md
index 83421246..f7fe1081 100644
--- a/docs/mcp-inspector.md
+++ b/docs/mcp-inspector.md
@@ -1,39 +1,31 @@
 # MCP Inspector
 
-The MCP Inspector lets an OpenShift Console user inspect and run tools exposed by an MCP Gateway. The browser connects directly to the endpoint reported in `MCPGatewayExtension.status.mcpEndpoint`; the console plugin does not proxy MCP traffic.
+The MCP Inspector lets an OpenShift Console user inspect and run tools exposed by an MCP Gateway. Browser requests remain on the OpenShift Console origin and pass through the Console plugin backend. The backend resolves the selected `MCPGatewayExtension.status.mcpEndpoint` for each request and relays the MCP exchange to that gateway.
 
 ## Prerequisites
 
 - The `MCPGatewayExtension` must have a `Ready=True` condition and a non-empty `status.mcpEndpoint`.
-- The gateway must allow the OpenShift Console origin through CORS, including the MCP protocol and session headers used by Streamable HTTP.
-- The plugin's `ConsolePlugin.spec.contentSecurityPolicy` must allow the MCP and OIDC origins with the `ConnectSrc` directive when Console CSP is enabled.
-- Production gateways should require authentication. An unauthenticated gateway reachable from a user's browser can be called by malicious websites if its CORS policy permits their origins.
+- The Kuadrant Operator must deploy the Console plugin backend and reconcile its `ConsolePlugin.spec.proxy` entry with `authorization: UserToken`.
+- The Console user must have Kubernetes `get` access to the selected `MCPGatewayExtension`.
+- A bearer token supplied for an MCP gateway is only forwarded over HTTPS. The insecure-auth override is for local development only.
 
-## Content Security Policy
+## Proxy and security model
 
-OpenShift Console reports a `connect-src` violation when the inspector connects to an origin that is not listed by an enabled `ConsolePlugin`. Current Console releases report these violations without blocking the request, but the required origins should still be declared so the inspector continues to work when CSP is enforced.
+The UI sends MCP JSON-RPC requests to the same-origin Console path:
 
-Add every MCP gateway origin and every OIDC origin used for discovery, client registration, or token exchange to the plugin resource. For example:
-
-```yaml
-spec:
-  contentSecurityPolicy:
-    - directive: ConnectSrc
-      values:
-        - https://mcp.example.com
-        - https://sso.example.com
+```text
+/api/proxy/plugin/kuadrant-console-plugin/backend/api/mcp/v1/gateways/<namespace>/<name>
 ```
 
-Console does not permit `*` as a CSP value, so deployments with gateway endpoints on different origins must maintain this allowlist as gateways are added or removed. The development Console accepts the equivalent bridge setting, for example `BRIDGE_CONTENT_SECURITY_POLICY="connect-src=ws://localhost:9001 http://mcp.127-0-0-1.sslip.io:8080"`.
+Console supplies the current OpenShift user token to the backend. The backend uses that token only for a fresh Kubernetes API lookup of the named `MCPGatewayExtension`; it is never sent to the MCP gateway. This makes endpoint selection subject to the user's Kubernetes RBAC and avoids maintaining a cluster-wide CSP or CORS allowlist for gateway hosts.
 
-## Authentication
+The backend accepts only the Inspector's current MCP methods (`initialize`, `notifications/initialized`, `tools/list`, and `tools/call`), limits request size, rejects redirects, and relays only the protocol, session, content, and authentication-challenge headers needed by Streamable HTTP.
 
-The inspector first attempts an unauthenticated MCP `initialize` request. If the gateway returns a `401` challenge, the user can:
+## Authentication
 
-- sign in with OIDC using authorization-server discovery, dynamic client registration, authorization code, and PKCE; or
-- paste a bearer token that is sent as an `Authorization: Bearer` header.
+The inspector first attempts an MCP `initialize` request without a gateway credential. If the gateway returns a `401` challenge, the user can paste a bearer token. The browser sends it to the plugin backend in a dedicated header, and the backend translates it to `Authorization: Bearer` only for the selected MCP gateway.
 
-Access tokens and MCP session IDs are held in memory only. Temporary PKCE callback state is held in `sessionStorage` and removed after the callback. Requests use `credentials: omit`; browser cookies are not sent to the MCP endpoint.
+Bearer tokens and MCP session IDs are held in memory only. OIDC sign-in is not currently supported by the Inspector.
 
 ## Using the inspector
 
diff --git a/docs/overview.md b/docs/overview.md
index 639629e1..f0d4d995 100644
--- a/docs/overview.md
+++ b/docs/overview.md
@@ -22,7 +22,7 @@ The **MCP management** section provides setup and management for MCP (Model Cont
 
 - **Overview** - when no MCPGatewayExtensions exist, shows a guided setup wizard for creating MCP infrastructure. Once extensions are created, shows a dashboard with summary cards for MCP Gateways (Total, Healthy, Unhealthy) and MCP Servers (Types, Total, Online, Offline). Includes tables for MCP Gateway Extensions, MCP Servers, Reference Grants, and Policies attached to MCP gateways or servers. Each table has toolbar filters and RBAC-aware create actions.
 - **MCP Gateway Setup Wizard** - 4-step wizard that walks through selecting or creating a Gateway, HTTPRoute, and MCPGatewayExtension resource. Supports both existing resource selection and inline creation of new resources. Resources are created sequentially in the final verification step, with live status watching for the MCPGatewayExtension Ready condition.
-- **MCP Inspector** - connects the browser directly to a Ready MCPGatewayExtension, lists and refreshes tools, creates inputs from each tool's JSON schema, and displays tool results with JSON-RPC request telemetry. See the [MCP Inspector guide](mcp-inspector.md).
+- **MCP Inspector** - connects to a Ready MCPGatewayExtension through the Console plugin backend, lists and refreshes tools, creates inputs from each tool's JSON schema, and displays tool results with JSON-RPC request telemetry. See the [MCP Inspector guide](mcp-inspector.md).
 
 Key resources managed on this page:
 
diff --git a/e2e/README.md b/e2e/README.md
index 79f52316..64036f5f 100644
--- a/e2e/README.md
+++ b/e2e/README.md
@@ -9,6 +9,7 @@
 ## Installation
 
 ### Install oinc
+
 ```bash
 OINC_VERSION="v0.4.3"
 curl -fL -o oinc "https://github.com/jasonmadigan/oinc/releases/download/${OINC_VERSION}/oinc-linux-amd64"
@@ -18,6 +19,7 @@ sudo mv oinc /usr/local/bin/
 ```
 
 ### Install Playwright browsers
+
 ```bash
 npx playwright install chromium --with-deps
 # If you get sudo errors, install without system deps:
@@ -56,7 +58,7 @@ npx playwright test e2e/tests/apikey-lifecycle.spec.ts --config=e2e/playwright.c
 
 ```bash
 # Check if cluster is running
-oinc list
+oinc status
 
 # Check if servers are running
 curl http://localhost:9000  # Console
@@ -79,6 +81,13 @@ npx playwright test --config=e2e/playwright.config.ts
 - `e2e/tests/apiproduct-overview-tab.spec.ts` - API product overview tab
 - `e2e/tests/apiproduct-rbac.spec.ts` - API product RBAC
 - `e2e/tests/api-product-list.spec.ts` - API product list page
+- `e2e/tests/attached-tab.spec.ts` - attached-policy tab behaviour
+- `e2e/tests/data-view-regressions.spec.ts` - shared data-view regressions
+- `e2e/tests/gateway-crud.spec.ts` - Gateway CRUD workflows
+- `e2e/tests/httproute-crud.spec.ts` - HTTPRoute CRUD workflows
+- `e2e/tests/mcp-inspector.spec.ts` - MCP Inspector smoke and live tool-call journeys
+- `e2e/tests/mcp-overview.spec.ts` - MCP management overview
+- `e2e/tests/mcp-setup-wizard.spec.ts` - MCP setup wizard
 - `e2e/tests/overview.spec.ts` - Overview dashboard cards, stats, and navigation
 - `e2e/tests/policy-forms.spec.ts` - Policy creation forms (DNS, TLS, Auth, RateLimit, etc.)
 - `e2e/tests/rbac.spec.ts` - RBAC permission tests
@@ -100,14 +109,17 @@ run executes every spec in `e2e/tests/`.
 ## Troubleshooting
 
 ### Tests fail with "Cannot navigate to invalid URL"
+
 - Make sure you use `--config=e2e/playwright.config.ts`
 - Check that console is running: `curl http://localhost:9000`
 
 ### Tests timeout looking for elements
+
 - Check that plugin dev server is running: `curl http://localhost:9001`
 - Check test screenshots in `test-results/` directory
 
 ### API key not approved automatically
+
 - Check if Kuadrant controller is running:
   ```bash
   kubectl get pods -n kuadrant-system
@@ -118,6 +130,7 @@ run executes every spec in `e2e/tests/`.
   ```
 
 ### View test results
+
 ```bash
 # Open HTML report
 npx playwright show-report
@@ -133,7 +146,7 @@ ls -la test-results/*/test-failed-*.png
 sudo ./e2e/teardown.sh
 
 # Or destroy entire oinc cluster
-oinc destroy
+oinc delete --force
 ```
 
 ## Important Notes
diff --git a/e2e/tests/mcp-inspector.spec.ts b/e2e/tests/mcp-inspector.spec.ts
index 18622827..384a3101 100644
--- a/e2e/tests/mcp-inspector.spec.ts
+++ b/e2e/tests/mcp-inspector.spec.ts
@@ -33,6 +33,13 @@ test.describe('MCP Inspector', () => {
     expect(namespace).toBeTruthy();
     expect(extensionName).toBeTruthy();
 
+    const cspViolations: string[] = [];
+    page.on('console', (message) => {
+      if (message.text().includes('Content Security Policy violation')) {
+        cspViolations.push(message.text());
+      }
+    });
+
     await openInspector(page, namespace);
     await page
       .getByLabel('Select an MCP gateway extension')
@@ -62,5 +69,6 @@ test.describe('MCP Inspector', () => {
       1,
     );
     await expect(page.getByRole('heading', { name: 'JSON-RPC response' })).toBeVisible();
+    expect(cspViolations).toEqual([]);
   });
 });
diff --git a/entrypoint.sh b/entrypoint.sh
deleted file mode 100755
index d1ec4727..00000000
--- a/entrypoint.sh
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/bin/bash
-
-# Inject topology ConfigMap location and metrics configuration
-cat <<EOF > /tmp/config.js
-window.kuadrant_config = {
-  TOPOLOGY_CONFIGMAP_NAME: '${TOPOLOGY_CONFIGMAP_NAME:-topology}',
-  TOPOLOGY_CONFIGMAP_NAMESPACE: '${TOPOLOGY_CONFIGMAP_NAMESPACE:-kuadrant-system}',
-  METRICS_WORKLOAD_SUFFIX: '${METRICS_WORKLOAD_SUFFIX:-openshift-default}'
-};
-EOF
-
-# Start Nginx
-nginx -g "daemon off;"
diff --git a/go.mod b/go.mod
new file mode 100644
index 00000000..ecdb4d63
--- /dev/null
+++ b/go.mod
@@ -0,0 +1,3 @@
+module github.com/Kuadrant/kuadrant-console-plugin
+
+go 1.24.0
diff --git a/install.yaml b/install.yaml
index 2bf37cbe..b0849f64 100644
--- a/install.yaml
+++ b/install.yaml
@@ -25,36 +25,33 @@ spec:
         app.kubernetes.io/part-of: kuadrant-console-plugin
     spec:
       containers:
-      - name: kuadrant-console-plugin
-        image: quay.io/kuadrant/console-plugin:latest
-        ports:
-        - containerPort: 9443
-          protocol: TCP
-        imagePullPolicy: Always
-        env:
-          - name: TOPOLOGY_CONFIGMAP_NAME
-            value: topology
-          - name: TOPOLOGY_CONFIGMAP_NAMESPACE
-            value: kuadrant-system
-          - name: METRICS_WORKLOAD_SUFFIX
-            value: -openshift-default
-        volumeMounts:
-        - name: plugin-serving-cert
-          readOnly: true
-          mountPath: /var/serving-cert
-        - name: nginx-conf
-          readOnly: true
-          mountPath: /etc/nginx/nginx.conf
-          subPath: nginx.conf
+        - name: kuadrant-console-plugin
+          image: quay.io/kuadrant/console-plugin:latest
+          ports:
+            - name: https
+              containerPort: 9443
+              protocol: TCP
+          imagePullPolicy: Always
+          env:
+            - name: TOPOLOGY_CONFIGMAP_NAME
+              value: topology
+            - name: TOPOLOGY_CONFIGMAP_NAMESPACE
+              value: kuadrant-system
+            - name: METRICS_WORKLOAD_SUFFIX
+              value: -openshift-default
+            - name: TLS_CERTIFICATE_FILE
+              value: /var/serving-cert/tls.crt
+            - name: TLS_KEY_FILE
+              value: /var/serving-cert/tls.key
+          volumeMounts:
+            - name: plugin-serving-cert
+              readOnly: true
+              mountPath: /var/serving-cert
       volumes:
-      - name: plugin-serving-cert
-        secret:
-          secretName: plugin-serving-cert
-          defaultMode: 420
-      - name: nginx-conf
-        configMap:
-          name: nginx-conf
-          defaultMode: 420
+        - name: plugin-serving-cert
+          secret:
+            secretName: plugin-serving-cert
+            defaultMode: 420
       restartPolicy: Always
       dnsPolicy: ClusterFirst
   strategy:
@@ -64,44 +61,6 @@ spec:
       maxSurge: 25%
 ---
 apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: nginx-conf
-  namespace: kuadrant-system
-  labels:
-    app: kuadrant-console-plugin
-    app.kubernetes.io/component: kuadrant-console-plugin
-    app.kubernetes.io/instance: kuadrant-console-plugin
-    app.kubernetes.io/name: kuadrant-console-plugin
-    app.kubernetes.io/part-of: kuadrant-console-plugin
-data:
-  nginx.conf: |
-    error_log /dev/stdout;
-    events {}
-    http {
-      access_log         /dev/stdout;
-      include            /etc/nginx/mime.types;
-      default_type       application/octet-stream;
-      keepalive_timeout  65;
-
-      server {
-        listen              9443 ssl;
-        listen              [::]:9443 ssl;
-        ssl_certificate     /var/serving-cert/tls.crt;
-        ssl_certificate_key /var/serving-cert/tls.key;
-
-        location / {
-          root                /usr/share/nginx/html;
-        }
-
-        # Serve config.js from /tmp
-        location /config.js {
-          root /tmp;
-        }
-      }
-    }
----
-apiVersion: v1
 kind: Service
 metadata:
   annotations:
@@ -116,10 +75,10 @@ metadata:
     app.kubernetes.io/part-of: kuadrant-console-plugin
 spec:
   ports:
-  - name: 9443-tcp
-    protocol: TCP
-    port: 9443
-    targetPort: 9443
+    - name: 9443-tcp
+      protocol: TCP
+      port: 9443
+      targetPort: 9443
   selector:
     app: kuadrant-console-plugin
   type: ClusterIP
@@ -140,3 +99,12 @@ spec:
       namespace: kuadrant-system
       port: 9443
       basePath: '/'
+  proxy:
+    - alias: backend
+      authorization: UserToken
+      endpoint:
+        type: Service
+        service:
+          name: kuadrant-console-plugin
+          namespace: kuadrant-system
+          port: 9443
diff --git a/locales/en/plugin__kuadrant-console-plugin.json b/locales/en/plugin__kuadrant-console-plugin.json
index 5bb1f10c..7f57c69f 100644
--- a/locales/en/plugin__kuadrant-console-plugin.json
+++ b/locales/en/plugin__kuadrant-console-plugin.json
@@ -901,8 +901,7 @@
   "Server": "Server",
   "Server result": "Server result",
   "Session logs are not available yet.": "Session logs are not available yet.",
-  "Sign in with OIDC": "Sign in with OIDC",
-  "This MCP gateway requires authentication. Sign in with OIDC or provide a bearer token.": "This MCP gateway requires authentication. Sign in with OIDC or provide a bearer token.",
+  "This MCP gateway requires authentication. Provide a bearer token for the MCP gateway.": "This MCP gateway requires authentication. Provide a bearer token for the MCP gateway.",
   "Tool call output": "Tool call output",
   "Tools": "Tools",
   "Validate only": "Validate only",
diff --git a/scripts/sync-console-plugin-proxy.sh b/scripts/sync-console-plugin-proxy.sh
new file mode 100755
index 00000000..a8dd701e
--- /dev/null
+++ b/scripts/sync-console-plugin-proxy.sh
@@ -0,0 +1,27 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Reconfigure OINC's standalone development Console from the ConsolePlugin
+# proxy contract reconciled by the Kuadrant Operator. This has no production
+# deployment role; a real OpenShift Console operator performs the translation.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+REPO_DIR="$(cd "${SCRIPT_DIR}/.." && pwd)"
+
+# shellcheck source=lib.sh
+source "${SCRIPT_DIR}/lib.sh"
+
+OINC_BIN="${OINC_BIN:-oinc}"
+CONSOLE_PORT="${CONSOLE_PORT:-9000}"
+PLUGIN_PORT="${PLUGIN_PORT:-9001}"
+PLUGIN_NAME=$(node -p "require('${REPO_DIR}/package.json').consolePlugin.name")
+RUNTIME=$(detect_runtime)
+HOST=$(container_host "${RUNTIME}")
+
+check_command "${OINC_BIN}" "Install an OINC build with console sync-plugin-proxy support"
+
+"${OINC_BIN}" console sync-plugin-proxy "${PLUGIN_NAME}" \
+  --console-plugin "${PLUGIN_NAME}=http://${HOST}:${PLUGIN_PORT}" \
+  --console-port "${CONSOLE_PORT}"
+
+log "OINC Console now uses the operator-reconciled plugin proxy; reload the browser"
diff --git a/src/components/mcp/MCPInspectorPage.test.tsx b/src/components/mcp/MCPInspectorPage.test.tsx
index 8eb5e090..18594a1c 100644
--- a/src/components/mcp/MCPInspectorPage.test.tsx
+++ b/src/components/mcp/MCPInspectorPage.test.tsx
@@ -133,7 +133,7 @@ describe('MCPInspectorPage', () => {
     expect(screen.getByText('No results')).toBeInTheDocument();
   });
 
-  it('offers OIDC and an in-memory bearer token after an authentication challenge', async () => {
+  it('offers an in-memory bearer token after an authentication challenge', async () => {
     (MCPClient as jest.Mock).mockImplementationOnce(() => ({
       initialize: jest
         .fn()
@@ -152,15 +152,16 @@ describe('MCPInspectorPage', () => {
 
     const dialog = await screen.findByRole('dialog', { name: 'Authentication required' });
     expect(dialog).toBeInTheDocument();
-    expect(screen.getByRole('button', { name: 'Sign in with OIDC' })).toBeInTheDocument();
+    expect(screen.queryByRole('button', { name: 'Sign in with OIDC' })).not.toBeInTheDocument();
 
     fireEvent.change(screen.getByLabelText('Bearer token'), { target: { value: 'test-token' } });
     fireEvent.click(screen.getByRole('button', { name: 'Connect with bearer token' }));
 
     await waitFor(() => expect(screen.getByText('Connected')).toBeInTheDocument());
-    expect(MCPClient).toHaveBeenLastCalledWith('https://mcp.example.test/mcp', {
-      token: 'test-token',
-    });
+    expect(MCPClient).toHaveBeenLastCalledWith(
+      '/api/proxy/plugin/kuadrant-console-plugin/backend/api/mcp/v1/gateways/test-ns/mcp-gateway',
+      { token: 'test-token' },
+    );
     expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
   });
 
diff --git a/src/components/mcp/MCPInspectorPage.tsx b/src/components/mcp/MCPInspectorPage.tsx
index 7b235984..6b9c08ae 100644
--- a/src/components/mcp/MCPInspectorPage.tsx
+++ b/src/components/mcp/MCPInspectorPage.tsx
@@ -13,7 +13,6 @@ import {
   Alert,
   Stack,
   StackItem,
-  Divider,
   EmptyState,
   EmptyStateBody,
   Tab,
@@ -45,14 +44,6 @@ import {
   ToolsCallResult,
   MCPCallExchange,
 } from '../../utils/mcp/client';
-import {
-  beginPkce,
-  clearPkceStorage,
-  completePkce,
-  peekOauthCallback,
-  stashOauthCallback,
-  takeOauthExchangeLock,
-} from '../../utils/mcp/oauth';
 import MCPToolWorkspace from './MCPToolWorkspace';
 import MCPInspectorOutput from './MCPInspectorOutput';
 import './MCPInspectorPage.css';
@@ -65,6 +56,11 @@ const isReady = (ext: MCPGatewayExtension): boolean =>
 const extKey = (ext: MCPGatewayExtension): string =>
   `${ext.metadata?.namespace}/${ext.metadata?.name}`;
 
+const proxyEndpoint = (ext: MCPGatewayExtension): string =>
+  `/api/proxy/plugin/kuadrant-console-plugin/backend/api/mcp/v1/gateways/${encodeURIComponent(
+    ext.metadata?.namespace ?? '',
+  )}/${encodeURIComponent(ext.metadata?.name ?? '')}`;
+
 const MCPInspectorPage: React.FC = () => {
   const { t } = useTranslation('plugin__kuadrant-console-plugin');
   const [activeNamespace] = useActiveNamespace();
@@ -79,7 +75,7 @@ const MCPInspectorPage: React.FC = () => {
   const [selectedKey, setSelectedKey] = React.useState('');
   const [bearerToken, setBearerToken] = React.useState('');
   const [authChallenge, setAuthChallenge] = React.useState<{
-    mcpEndpoint: string;
+    proxyEndpoint: string;
     selectedKey: string;
     wwwAuthenticate: string | null;
   } | null>(null);
@@ -88,7 +84,7 @@ const MCPInspectorPage: React.FC = () => {
   const clientRef = React.useRef<MCPClient | null>(null);
   const [sessionId, setSessionId] = React.useState<string | null>(null);
   const [connected, setConnected] = React.useState(false);
-  const [authMode, setAuthMode] = React.useState<'none' | 'bearer' | 'oidc'>('none');
+  const [authMode, setAuthMode] = React.useState<'none' | 'bearer'>('none');
   const [activeSection, setActiveSection] = React.useState<string | number>(0);
   const [tools, setTools] = React.useState<MCPTool[]>([]);
 
@@ -115,12 +111,12 @@ const MCPInspectorPage: React.FC = () => {
   );
   const endpoint = selected?.status?.mcpEndpoint ?? '';
 
-  const runSession = async (mcpEndpoint: string, bearer?: string) => {
+  const runSession = async (inspectorEndpoint: string, bearer?: string) => {
     setError('');
     setSessionExpired(false);
     setTools([]);
     setCallExchange(null);
-    const client = new MCPClient(mcpEndpoint, { token: bearer || undefined });
+    const client = new MCPClient(inspectorEndpoint, { token: bearer || undefined });
     const { sessionId: id } = await client.initialize();
     await client.sendInitialized();
     const listed = await client.toolsList();
@@ -131,16 +127,16 @@ const MCPInspectorPage: React.FC = () => {
   };
 
   const handleConnect = async (
-    mcpEndpoint = endpoint,
+    inspectorEndpoint: string,
     selectedExtensionKey = selectedKey,
     bearer?: string,
   ) => {
-    if (!mcpEndpoint) {
+    if (!inspectorEndpoint) {
       return;
     }
     setConnecting(true);
     try {
-      await runSession(mcpEndpoint, bearer);
+      await runSession(inspectorEndpoint, bearer);
       setAuthMode(bearer ? 'bearer' : 'none');
       setAuthChallenge(null);
     } catch (err) {
@@ -150,7 +146,7 @@ const MCPInspectorPage: React.FC = () => {
       if (err instanceof MCPUnauthorizedError && !bearer) {
         setError('');
         setAuthChallenge({
-          mcpEndpoint,
+          proxyEndpoint: inspectorEndpoint,
           selectedKey: selectedExtensionKey,
           wwwAuthenticate: err.wwwAuthenticate,
         });
@@ -181,21 +177,7 @@ const MCPInspectorPage: React.FC = () => {
     }
     const extension = list.find((item) => extKey(item) === value);
     if (extension?.status?.mcpEndpoint && isReady(extension)) {
-      void handleConnect(extension.status.mcpEndpoint, value);
-    }
-  };
-
-  const handleOidcSignIn = async () => {
-    if (!authChallenge) {
-      return;
-    }
-    setConnecting(true);
-    setError('');
-    try {
-      await beginPkce(authChallenge);
-    } catch (err) {
-      setError(err instanceof Error ? err.message : String(err));
-      setConnecting(false);
+      void handleConnect(proxyEndpoint(extension), value);
     }
   };
 
@@ -203,50 +185,9 @@ const MCPInspectorPage: React.FC = () => {
     if (!authChallenge || !bearerToken.trim()) {
       return;
     }
-    void handleConnect(authChallenge.mcpEndpoint, authChallenge.selectedKey, bearerToken.trim());
+    void handleConnect(authChallenge.proxyEndpoint, authChallenge.selectedKey, bearerToken.trim());
   };
 
-  React.useEffect(() => {
-    const params = new URLSearchParams(window.location.search);
-    const oauthError = params.get('error');
-    if (oauthError) {
-      const description = params.get('error_description') || oauthError;
-      setError(description);
-      clearPkceStorage();
-      window.history.replaceState({}, '', window.location.pathname);
-      return;
-    }
-    const code = params.get('code');
-    const state = params.get('state');
-    if (code && state) {
-      stashOauthCallback(code, state);
-      window.history.replaceState({}, '', window.location.pathname);
-    }
-    if (!peekOauthCallback()) {
-      return;
-    }
-    if (!takeOauthExchangeLock()) {
-      return;
-    }
-    setConnecting(true);
-    void (async () => {
-      try {
-        const result = await completePkce();
-        setSelectedKey(result.selectedKey);
-        await runSession(result.mcpEndpoint, result.accessToken);
-        setAuthMode('oidc');
-      } catch (err) {
-        clientRef.current = null;
-        setSessionId(null);
-        setConnected(false);
-        setError(err instanceof Error ? err.message : String(err));
-      } finally {
-        setConnecting(false);
-      }
-    })();
-    // OAuth callback state is consumed only once when the inspector mounts.
-  }, []);
-
   const handleCall = async (
     toolName: string,
     args: Record<string, unknown>,
@@ -514,18 +455,10 @@ const MCPInspectorPage: React.FC = () => {
             <StackItem>
               <Content component="p">
                 {t(
-                  'This MCP gateway requires authentication. Sign in with OIDC or provide a bearer token.',
+                  'This MCP gateway requires authentication. Provide a bearer token for the MCP gateway.',
                 )}
               </Content>
             </StackItem>
-            <StackItem>
-              <Button variant="primary" onClick={handleOidcSignIn} isLoading={connecting}>
-                {t('Sign in with OIDC')}
-              </Button>
-            </StackItem>
-            <StackItem>
-              <Divider />
-            </StackItem>
             <StackItem>
               <FormGroup label={t('Bearer token')} fieldId="mcp-inspector-bearer-token">
                 <TextInput
diff --git a/src/utils/mcp/client.test.ts b/src/utils/mcp/client.test.ts
index d8387064..2c5785e5 100644
--- a/src/utils/mcp/client.test.ts
+++ b/src/utils/mcp/client.test.ts
@@ -1,4 +1,10 @@
 import { MCPClient } from './client';
+import { consoleFetch } from '@openshift-console/dynamic-plugin-sdk';
+
+jest.mock('@openshift-console/dynamic-plugin-sdk', () => ({
+  consoleFetch: jest.fn(),
+  HttpError: class HttpError extends Error {},
+}));
 
 const jsonResponse = (body: unknown, status = 200, statusText = 'OK') =>
   ({
@@ -13,7 +19,7 @@ const jsonResponse = (body: unknown, status = 200, statusText = 'OK') =>
 
 describe('MCPClient', () => {
   beforeEach(() => {
-    global.fetch = jest.fn();
+    (consoleFetch as jest.Mock).mockReset();
   });
 
   afterEach(() => {
@@ -21,7 +27,7 @@ describe('MCPClient', () => {
   });
 
   it('returns request, response, HTTP status and duration for a tool call', async () => {
-    (global.fetch as jest.Mock).mockResolvedValue(
+    (consoleFetch as jest.Mock).mockResolvedValue(
       jsonResponse({
         jsonrpc: '2.0',
         id: 1,
@@ -29,7 +35,10 @@ describe('MCPClient', () => {
       }),
     );
     jest.spyOn(Date, 'now').mockReturnValueOnce(100).mockReturnValueOnce(145);
-    const client = new MCPClient('https://mcp.example.test/mcp', { token: 'test-token' });
+    const client = new MCPClient(
+      '/api/proxy/plugin/kuadrant-console-plugin/backend/api/mcp/v1/gateways/test-ns/test',
+      { token: 'test-token' },
+    );
 
     const exchange = await client.toolsCallWithDetails(
       'toystore_greet',
@@ -58,13 +67,13 @@ describe('MCPClient', () => {
       statusText: 'OK',
       durationMs: 45,
     });
-    expect(global.fetch).toHaveBeenCalledWith(
-      'https://mcp.example.test/mcp',
+    expect(consoleFetch).toHaveBeenCalledWith(
+      '/api/proxy/plugin/kuadrant-console-plugin/backend/api/mcp/v1/gateways/test-ns/test',
       expect.objectContaining({
         method: 'POST',
-        credentials: 'omit',
+        credentials: 'same-origin',
         headers: expect.objectContaining({
-          Authorization: 'Bearer test-token',
+          'X-Kuadrant-MCP-Authorization': 'Bearer test-token',
           'MCP-Protocol-Version': '2025-11-25',
         }),
       }),
diff --git a/src/utils/mcp/client.ts b/src/utils/mcp/client.ts
index ce562e9a..d07b7a47 100644
--- a/src/utils/mcp/client.ts
+++ b/src/utils/mcp/client.ts
@@ -1,5 +1,7 @@
-// Dependency-free MCP Streamable HTTP client. It speaks JSON-RPC 2.0 over a
-// single endpoint, handles JSON and SSE responses, and keeps the session ID in
+import { consoleFetch, HttpError } from '@openshift-console/dynamic-plugin-sdk';
+
+// MCP Streamable HTTP client. It speaks JSON-RPC 2.0 through the Console
+// plugin proxy, handles JSON and SSE responses, and keeps the session ID in
 // memory only (the caller holds it in React state).
 
 export const MCP_PROTOCOL_VERSION = '2025-11-25';
@@ -222,7 +224,7 @@ export class MCPClient {
     return new MCPHttpError(status, `${context} (http ${status})`);
   }
 
-  private post(body: Record<string, unknown>): Promise<Response> {
+  private async post(body: Record<string, unknown>): Promise<Response> {
     const headers: Record<string, string> = {
       'Content-Type': 'application/json',
       Accept: 'application/json, text/event-stream',
@@ -232,14 +234,27 @@ export class MCPClient {
       headers['Mcp-Session-Id'] = this.sessionId;
     }
     if (this.token) {
-      headers.Authorization = `Bearer ${this.token}`;
+      // Console owns the ordinary Authorization header and replaces it with
+      // the current OpenShift user token. The backend translates this explicit
+      // MCP credential to Authorization only for the selected MCP gateway.
+      headers['X-Kuadrant-MCP-Authorization'] = `Bearer ${this.token}`;
+    }
+    try {
+      return await consoleFetch(this.endpoint, {
+        method: 'POST',
+        credentials: 'same-origin',
+        headers,
+        body: JSON.stringify(body),
+      });
+    } catch (error) {
+      // The MCP handshake needs the upstream status and WWW-Authenticate
+      // header. consoleFetch deliberately throws on non-2xx responses, but its
+      // HttpError retains the original response for this purpose.
+      if (error instanceof HttpError && error.response) {
+        return error.response;
+      }
+      throw error;
     }
-    return fetch(this.endpoint, {
-      method: 'POST',
-      credentials: 'omit',
-      headers,
-      body: JSON.stringify(body),
-    });
   }
 }
 
diff --git a/start-local.sh b/start-local.sh
index d3025293..83969438 100755
--- a/start-local.sh
+++ b/start-local.sh
@@ -35,8 +35,10 @@ PLUGIN_NAME=$(node -p "require('${SCRIPT_DIR}/package.json').consolePlugin.name"
 PLUGIN_URL="http://${HOST}:${PLUGIN_PORT}"
 
 console_has_plugin() {
-  "${RUNTIME}" inspect oinc-console --format '{{json .Config.Cmd}}' 2>/dev/null \
-    | grep -q "${PLUGIN_NAME}"
+  {
+    "${RUNTIME}" inspect oinc-console --format '{{range .Config.Env}}{{println .}}{{end}}' 2>/dev/null
+    "${RUNTIME}" inspect oinc-console --format '{{json .Config.Cmd}}' 2>/dev/null
+  } | grep -q "${PLUGIN_NAME}"
 }
 
 restart_console_with_plugin() {

From b6d85409120185549d8e1ab77a3bf1b5f42538a1 Mon Sep 17 00:00:00 2001
From: Jason Madigan <jason@jasonmadigan.com>
Date: Wed, 26 Aug 2026 09:15:37 +0100
Subject: [PATCH 4/4] fix: resolve MCP endpoint from target gateway listener

Signed-off-by: Jason Madigan <jason@jasonmadigan.com>
---
 cmd/plugin-server/main.go                    | 132 +++++++++++++++++--
 cmd/plugin-server/main_test.go               |  97 +++++++++++++-
 docs/mcp-inspector.md                        |  10 +-
 src/components/mcp/MCPInspectorPage.test.tsx |   4 +-
 src/components/mcp/MCPInspectorPage.tsx      |   8 +-
 src/components/mcp/types.ts                  |   1 -
 src/utils/mcp/client.test.ts                 |   4 +-
 7 files changed, 228 insertions(+), 28 deletions(-)

diff --git a/cmd/plugin-server/main.go b/cmd/plugin-server/main.go
index b74e1f77..7ac2af79 100644
--- a/cmd/plugin-server/main.go
+++ b/cmd/plugin-server/main.go
@@ -15,13 +15,14 @@ import (
 	"os"
 	"os/signal"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"syscall"
 	"time"
 )
 
 const (
-	mcpProxyPrefix         = "/api/mcp/v1/gateways/"
+	mcpProxyPrefix         = "/api/mcp/v1/mcpgatewayextensions/"
 	mcpAuthorizationHeader = "X-Kuadrant-MCP-Authorization"
 	maxMCPRequestBytes     = 1024 * 1024
 )
@@ -52,15 +53,39 @@ type server struct {
 }
 
 type mcpGatewayExtension struct {
+	Metadata struct {
+		Generation int64 `json:"generation"`
+	} `json:"metadata"`
+	Spec struct {
+		PublicHost string `json:"publicHost"`
+		TargetRef  struct {
+			Name        string `json:"name"`
+			Namespace   string `json:"namespace"`
+			SectionName string `json:"sectionName"`
+		} `json:"targetRef"`
+	} `json:"spec"`
 	Status struct {
 		Conditions []struct {
-			Type   string `json:"type"`
-			Status string `json:"status"`
+			Type               string `json:"type"`
+			Status             string `json:"status"`
+			ObservedGeneration int64  `json:"observedGeneration"`
 		} `json:"conditions"`
-		MCPEndpoint string `json:"mcpEndpoint"`
 	} `json:"status"`
 }
 
+type gateway struct {
+	Spec struct {
+		Listeners []gatewayListener `json:"listeners"`
+	} `json:"spec"`
+}
+
+type gatewayListener struct {
+	Name     string `json:"name"`
+	Hostname string `json:"hostname"`
+	Protocol string `json:"protocol"`
+	Port     uint32 `json:"port"`
+}
+
 type kubernetesStatus struct {
 	Message string `json:"message"`
 }
@@ -294,7 +319,8 @@ func (s *server) resolveMCPEndpoint(ctx context.Context, namespace, name, author
 	if err != nil {
 		return "", http.StatusInternalServerError, errors.New("Kubernetes API URL is invalid")
 	}
-	baseURL.Path = filepath.ToSlash(filepath.Join(baseURL.Path, "apis/mcp.kuadrant.io/v1/namespaces", namespace, "mcpgatewayextensions", name))
+	apiBasePath := baseURL.Path
+	baseURL.Path = filepath.ToSlash(filepath.Join(apiBasePath, "apis/mcp.kuadrant.io/v1/namespaces", namespace, "mcpgatewayextensions", name))
 	lookup, err := http.NewRequestWithContext(ctx, http.MethodGet, baseURL.String(), nil)
 	if err != nil {
 		return "", http.StatusInternalServerError, errors.New("could not create Kubernetes API request")
@@ -324,15 +350,105 @@ func (s *server) resolveMCPEndpoint(ctx context.Context, namespace, name, author
 	}
 	ready := false
 	for _, condition := range extension.Status.Conditions {
-		if condition.Type == "Ready" && condition.Status == "True" {
+		if condition.Type == "Ready" && condition.Status == "True" && condition.ObservedGeneration == extension.Metadata.Generation {
 			ready = true
 			break
 		}
 	}
-	if !ready || extension.Status.MCPEndpoint == "" {
+	if !ready {
 		return "", http.StatusConflict, errors.New("MCPGatewayExtension is not ready")
 	}
-	return extension.Status.MCPEndpoint, http.StatusOK, nil
+
+	targetNamespace := extension.Spec.TargetRef.Namespace
+	if targetNamespace == "" {
+		targetNamespace = namespace
+	}
+	baseURL.Path = filepath.ToSlash(filepath.Join(
+		apiBasePath,
+		"apis/gateway.networking.k8s.io/v1/namespaces",
+		targetNamespace,
+		"gateways",
+		extension.Spec.TargetRef.Name,
+	))
+	lookup, err = http.NewRequestWithContext(ctx, http.MethodGet, baseURL.String(), nil)
+	if err != nil {
+		return "", http.StatusInternalServerError, errors.New("could not create Gateway API request")
+	}
+	lookup.Header.Set("Authorization", authorization)
+	lookup.Header.Set("Accept", "application/json")
+
+	response, err = s.kubernetesHTTP.Do(lookup)
+	if err != nil {
+		s.logger.Error("Gateway API lookup failed", "error", err)
+		return "", http.StatusBadGateway, errors.New("could not resolve MCP gateway listener")
+	}
+	defer response.Body.Close()
+	if response.StatusCode != http.StatusOK {
+		var status kubernetesStatus
+		_ = json.NewDecoder(io.LimitReader(response.Body, 64*1024)).Decode(&status)
+		message := status.Message
+		if message == "" {
+			message = "could not access the MCP Gateway listener"
+		}
+		return "", response.StatusCode, errors.New(message)
+	}
+
+	var targetGateway gateway
+	if err := json.NewDecoder(io.LimitReader(response.Body, 1024*1024)).Decode(&targetGateway); err != nil {
+		return "", http.StatusBadGateway, errors.New("Kubernetes API returned an invalid Gateway")
+	}
+	endpoint, err := deriveMCPEndpoint(&extension, &targetGateway)
+	if err != nil {
+		return "", http.StatusBadGateway, err
+	}
+	return endpoint, http.StatusOK, nil
+}
+
+func deriveMCPEndpoint(extension *mcpGatewayExtension, targetGateway *gateway) (string, error) {
+	sectionName := extension.Spec.TargetRef.SectionName
+	for _, listener := range targetGateway.Spec.Listeners {
+		if listener.Name != sectionName {
+			continue
+		}
+
+		host := extension.Spec.PublicHost
+		if host == "" {
+			host = listener.Hostname
+			if strings.HasPrefix(host, "*.") {
+				host = "mcp" + host[1:]
+			}
+		}
+		if strings.Contains(host, "://") {
+			return "", errors.New("MCPGatewayExtension has an invalid public host")
+		}
+		if hostname, _, err := net.SplitHostPort(host); err == nil {
+			host = hostname
+		}
+		if host == "" || strings.ContainsAny(host, "/?#@") {
+			return "", errors.New("MCPGatewayExtension has an invalid public host")
+		}
+
+		scheme := "http"
+		defaultPort := uint32(80)
+		switch {
+		case strings.EqualFold(listener.Protocol, "HTTP"):
+		case strings.EqualFold(listener.Protocol, "HTTPS"):
+			scheme = "https"
+			defaultPort = 443
+		default:
+			return "", errors.New("MCP Gateway listener must use HTTP or HTTPS")
+		}
+		if listener.Port == 0 {
+			return "", errors.New("MCP Gateway listener has an invalid port")
+		}
+
+		urlHost := host
+		if listener.Port != defaultPort {
+			urlHost = net.JoinHostPort(host, strconv.FormatUint(uint64(listener.Port), 10))
+		}
+		return (&url.URL{Scheme: scheme, Host: urlHost, Path: "/mcp"}).String(), nil
+	}
+	return "", errors.New("MCPGatewayExtension target listener was not found")
 }
 
 func allowedMCPMethod(method string) bool {
diff --git a/cmd/plugin-server/main_test.go b/cmd/plugin-server/main_test.go
index 5f10da0a..dd5c2e3b 100644
--- a/cmd/plugin-server/main_test.go
+++ b/cmd/plugin-server/main_test.go
@@ -13,6 +13,7 @@ import (
 
 func TestMCPProxyKeepsConsoleAndMCPAuthorizationSeparate(t *testing.T) {
 	var kubernetesAuthorization string
+	var kubernetesRequests int
 	var upstreamAuthorization string
 
 	upstream := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
@@ -25,19 +26,44 @@ func TestMCPProxyKeepsConsoleAndMCPAuthorizationSeparate(t *testing.T) {
 
 	kubernetes := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
 		kubernetesAuthorization = request.Header.Get("Authorization")
+		kubernetesRequests++
 		writer.Header().Set("Content-Type", "application/json")
-		_ = json.NewEncoder(writer).Encode(map[string]any{
-			"status": map[string]any{
-				"conditions":  []map[string]string{{"type": "Ready", "status": "True"}},
-				"mcpEndpoint": upstream.URL,
-			},
-		})
+		switch {
+		case strings.Contains(request.URL.Path, "/mcpgatewayextensions/"):
+			_ = json.NewEncoder(writer).Encode(map[string]any{
+				"metadata": map[string]any{"generation": 4},
+				"spec": map[string]any{
+					"publicHost": "mcp.example.test",
+					"targetRef": map[string]any{
+						"name":        "test-gateway",
+						"namespace":   "gateway-system",
+						"sectionName": "mcp",
+					},
+				},
+				"status": map[string]any{
+					"conditions": []map[string]any{{"type": "Ready", "status": "True", "observedGeneration": 4}},
+				},
+			})
+		case strings.Contains(request.URL.Path, "/gateways/"):
+			_ = json.NewEncoder(writer).Encode(map[string]any{
+				"spec": map[string]any{
+					"listeners": []map[string]any{{
+						"name":     "mcp",
+						"port":     80,
+						"protocol": "HTTP",
+					}},
+				},
+			})
+		default:
+			http.NotFound(writer, request)
+		}
 	}))
 	defer kubernetes.Close()
 
 	backend, err := newServer(config{
 		kubernetesAPIURL:     kubernetes.URL,
 		kubernetesSkipVerify: true,
+		upstreamDialAddress:  strings.TrimPrefix(upstream.URL, "http://"),
 		allowInsecureMCPAuth: true,
 		requestTimeout:       time.Second,
 	}, slog.New(slog.NewTextHandler(io.Discard, nil)))
@@ -62,6 +88,9 @@ func TestMCPProxyKeepsConsoleAndMCPAuthorizationSeparate(t *testing.T) {
 	if kubernetesAuthorization != "Bearer openshift-user-token" {
 		t.Fatalf("Kubernetes Authorization = %q", kubernetesAuthorization)
 	}
+	if kubernetesRequests != 2 {
+		t.Fatalf("Kubernetes requests = %d, want extension and Gateway lookups", kubernetesRequests)
+	}
 	if upstreamAuthorization != "Bearer mcp-gateway-token" {
 		t.Fatalf("MCP upstream Authorization = %q", upstreamAuthorization)
 	}
@@ -70,6 +99,62 @@ func TestMCPProxyKeepsConsoleAndMCPAuthorizationSeparate(t *testing.T) {
 	}
 }
 
+func TestDeriveMCPEndpoint(t *testing.T) {
+	tests := []struct {
+		name       string
+		publicHost string
+		section    string
+		listener   gatewayListener
+		want       string
+		wantErr    string
+	}{
+		{
+			name:       "public host on default HTTP port",
+			publicHost: "mcp.example.test",
+			section:    "mcp",
+			listener:   gatewayListener{Name: "mcp", Hostname: "ignored.example.test", Protocol: "HTTP", Port: 80},
+			want:       "http://mcp.example.test/mcp",
+		},
+		{
+			name:     "wildcard listener on non-default HTTPS port",
+			section:  "secure-mcp",
+			listener: gatewayListener{Name: "secure-mcp", Hostname: "*.example.test", Protocol: "HTTPS", Port: 8443},
+			want:     "https://mcp.example.test:8443/mcp",
+		},
+		{
+			name:       "missing target listener",
+			publicHost: "mcp.example.test",
+			section:    "other",
+			listener:   gatewayListener{Name: "mcp", Protocol: "HTTP", Port: 80},
+			wantErr:    "target listener was not found",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			extension := &mcpGatewayExtension{}
+			extension.Spec.PublicHost = test.publicHost
+			extension.Spec.TargetRef.SectionName = test.section
+			targetGateway := &gateway{}
+			targetGateway.Spec.Listeners = append(targetGateway.Spec.Listeners, test.listener)
+
+			got, err := deriveMCPEndpoint(extension, targetGateway)
+			if test.wantErr != "" {
+				if err == nil || !strings.Contains(err.Error(), test.wantErr) {
+					t.Fatalf("error = %v, want %q", err, test.wantErr)
+				}
+				return
+			}
+			if err != nil {
+				t.Fatal(err)
+			}
+			if got != test.want {
+				t.Fatalf("endpoint = %q, want %q", got, test.want)
+			}
+		})
+	}
+}
+
 func TestMCPProxyRequiresConsoleUserToken(t *testing.T) {
 	backend := &server{logger: slog.New(slog.NewTextHandler(io.Discard, nil))}
 	request := httptest.NewRequest(
diff --git a/docs/mcp-inspector.md b/docs/mcp-inspector.md
index f7fe1081..391abbe4 100644
--- a/docs/mcp-inspector.md
+++ b/docs/mcp-inspector.md
@@ -1,12 +1,12 @@
 # MCP Inspector
 
-The MCP Inspector lets an OpenShift Console user inspect and run tools exposed by an MCP Gateway. Browser requests remain on the OpenShift Console origin and pass through the Console plugin backend. The backend resolves the selected `MCPGatewayExtension.status.mcpEndpoint` for each request and relays the MCP exchange to that gateway.
+The MCP Inspector lets an OpenShift Console user inspect and run tools exposed by an MCP Gateway. Browser requests remain on the OpenShift Console origin and pass through the Console plugin backend. For each request, the backend reads the selected `MCPGatewayExtension`, follows its `spec.targetRef` to the Gateway listener, derives the MCP URL, and relays the exchange to that gateway.
 
 ## Prerequisites
 
-- The `MCPGatewayExtension` must have a `Ready=True` condition and a non-empty `status.mcpEndpoint`.
+- The `MCPGatewayExtension` must have a current `Ready=True` condition.
 - The Kuadrant Operator must deploy the Console plugin backend and reconcile its `ConsolePlugin.spec.proxy` entry with `authorization: UserToken`.
-- The Console user must have Kubernetes `get` access to the selected `MCPGatewayExtension`.
+- The Console user must have Kubernetes `get` access to the selected `MCPGatewayExtension` and its referenced Gateway.
 - A bearer token supplied for an MCP gateway is only forwarded over HTTPS. The insecure-auth override is for local development only.
 
 ## Proxy and security model
@@ -14,10 +14,10 @@ The MCP Inspector lets an OpenShift Console user inspect and run tools exposed b
 The UI sends MCP JSON-RPC requests to the same-origin Console path:
 
 ```text
-/api/proxy/plugin/kuadrant-console-plugin/backend/api/mcp/v1/gateways/<namespace>/<name>
+/api/proxy/plugin/kuadrant-console-plugin/backend/api/mcp/v1/mcpgatewayextensions/<namespace>/<name>
 ```
 
-Console supplies the current OpenShift user token to the backend. The backend uses that token only for a fresh Kubernetes API lookup of the named `MCPGatewayExtension`; it is never sent to the MCP gateway. This makes endpoint selection subject to the user's Kubernetes RBAC and avoids maintaining a cluster-wide CSP or CORS allowlist for gateway hosts.
+Console supplies the current OpenShift user token to the backend. The backend uses that token only to read the named `MCPGatewayExtension` and its referenced Gateway. It is never sent to the MCP gateway. The backend takes the host from `spec.publicHost`, or from the listener hostname when no override is set. It takes the scheme and port from the referenced listener and uses `/mcp` as the path. This keeps endpoint selection subject to the user's Kubernetes RBAC and avoids maintaining a cluster-wide CSP or CORS allowlist for gateway hosts.
 
 The backend accepts only the Inspector's current MCP methods (`initialize`, `notifications/initialized`, `tools/list`, and `tools/call`), limits request size, rejects redirects, and relays only the protocol, session, content, and authentication-challenge headers needed by Streamable HTTP.
 
diff --git a/src/components/mcp/MCPInspectorPage.test.tsx b/src/components/mcp/MCPInspectorPage.test.tsx
index 18594a1c..2c7cbe68 100644
--- a/src/components/mcp/MCPInspectorPage.test.tsx
+++ b/src/components/mcp/MCPInspectorPage.test.tsx
@@ -46,10 +46,10 @@ const readyExtension: MCPGatewayExtension = {
       name: 'mcp-gateway',
       sectionName: 'mcp',
     },
+    publicHost: 'mcp.example.test',
   },
   status: {
     conditions: [{ type: 'Ready', status: 'True' }],
-    mcpEndpoint: 'https://mcp.example.test/mcp',
   },
 };
 
@@ -159,7 +159,7 @@ describe('MCPInspectorPage', () => {
 
     await waitFor(() => expect(screen.getByText('Connected')).toBeInTheDocument());
     expect(MCPClient).toHaveBeenLastCalledWith(
-      '/api/proxy/plugin/kuadrant-console-plugin/backend/api/mcp/v1/gateways/test-ns/mcp-gateway',
+      '/api/proxy/plugin/kuadrant-console-plugin/backend/api/mcp/v1/mcpgatewayextensions/test-ns/mcp-gateway',
       { token: 'test-token' },
     );
     expect(screen.queryByRole('dialog')).not.toBeInTheDocument();
diff --git a/src/components/mcp/MCPInspectorPage.tsx b/src/components/mcp/MCPInspectorPage.tsx
index 6b9c08ae..e8804b4d 100644
--- a/src/components/mcp/MCPInspectorPage.tsx
+++ b/src/components/mcp/MCPInspectorPage.tsx
@@ -57,7 +57,7 @@ const extKey = (ext: MCPGatewayExtension): string =>
   `${ext.metadata?.namespace}/${ext.metadata?.name}`;
 
 const proxyEndpoint = (ext: MCPGatewayExtension): string =>
-  `/api/proxy/plugin/kuadrant-console-plugin/backend/api/mcp/v1/gateways/${encodeURIComponent(
+  `/api/proxy/plugin/kuadrant-console-plugin/backend/api/mcp/v1/mcpgatewayextensions/${encodeURIComponent(
     ext.metadata?.namespace ?? '',
   )}/${encodeURIComponent(ext.metadata?.name ?? '')}`;
 
@@ -109,7 +109,7 @@ const MCPInspectorPage: React.FC = () => {
     () => list.find((ext) => extKey(ext) === selectedKey),
     [list, selectedKey],
   );
-  const endpoint = selected?.status?.mcpEndpoint ?? '';
+  const endpoint = selected?.spec.publicHost ?? '';
 
   const runSession = async (inspectorEndpoint: string, bearer?: string) => {
     setError('');
@@ -176,7 +176,7 @@ const MCPInspectorPage: React.FC = () => {
       return;
     }
     const extension = list.find((item) => extKey(item) === value);
-    if (extension?.status?.mcpEndpoint && isReady(extension)) {
+    if (extension && isReady(extension)) {
       void handleConnect(proxyEndpoint(extension), value);
     }
   };
@@ -288,7 +288,7 @@ const MCPInspectorPage: React.FC = () => {
                             isPlaceholder
                           />
                           {list.map((ext) => {
-                            const reachable = !!ext.status?.mcpEndpoint && isReady(ext);
+                            const reachable = isReady(ext);
                             const name = `${ext.metadata?.name} (${ext.metadata?.namespace})`;
                             return (
                               <FormSelectOption
diff --git a/src/components/mcp/types.ts b/src/components/mcp/types.ts
index e54c2234..bc11989b 100644
--- a/src/components/mcp/types.ts
+++ b/src/components/mcp/types.ts
@@ -39,7 +39,6 @@ export interface MCPGatewayExtension extends K8sResourceCommon {
   };
   status?: {
     conditions?: Condition[];
-    mcpEndpoint?: string;
   };
 }
 
diff --git a/src/utils/mcp/client.test.ts b/src/utils/mcp/client.test.ts
index 2c5785e5..449402f0 100644
--- a/src/utils/mcp/client.test.ts
+++ b/src/utils/mcp/client.test.ts
@@ -36,7 +36,7 @@ describe('MCPClient', () => {
     );
     jest.spyOn(Date, 'now').mockReturnValueOnce(100).mockReturnValueOnce(145);
     const client = new MCPClient(
-      '/api/proxy/plugin/kuadrant-console-plugin/backend/api/mcp/v1/gateways/test-ns/test',
+      '/api/proxy/plugin/kuadrant-console-plugin/backend/api/mcp/v1/mcpgatewayextensions/test-ns/test',
       { token: 'test-token' },
     );
 
@@ -68,7 +68,7 @@ describe('MCPClient', () => {
       durationMs: 45,
     });
     expect(consoleFetch).toHaveBeenCalledWith(
-      '/api/proxy/plugin/kuadrant-console-plugin/backend/api/mcp/v1/gateways/test-ns/test',
+      '/api/proxy/plugin/kuadrant-console-plugin/backend/api/mcp/v1/mcpgatewayextensions/test-ns/test',
       expect.objectContaining({
         method: 'POST',
         credentials: 'same-origin',