Phase 1: Refactor all 16 element component interfaces to use MCP SDK types

Replace ad-hoc local type definitions in element components with real
MCP SDK types and Inspector wrapper types from core/mcp/types.ts:

Schema-typed primitives:
- LogLevelBadge: LogLevel → LoggingLevel (SDK)
- TransportBadge: "stdio"|"http" → ServerType (core), add sse/streamable-http
- TaskStatusBadge: local TaskStatus → SDK TaskStatus (working/input_required/...)
- ServerStatusIndicator: inline union → ConnectionStatus (core), "failed"→"error"

MCP wrapper consumers:
- AnnotationBadge: label+variant → facet+value with SDK Role type
- CapabilityItem: name:string → capability:keyof ServerCapabilities|ClientCapabilities
- LogEntry: flat props → entry:{receivedAt:Date, params:LoggingMessageNotification["params"]}
- MessageBubble: flat props → message:SamplingMessage|PromptMessage
- ProgressDisplay: flat props → params:ProgressNotification["params"]

Composite-input elements:
- ContentViewer: type+content+mimeType → block:ContentBlock (SDK discriminated union)
- InlineError: message+details → error:{message,data?}
- ConnectionToggle: checked+loading+onChange → status:ConnectionStatus+onConnect/onDisconnect

Also updates all group/screen/view consumers to keep the build green,
and renames CSS variable --inspector-status-failed → --inspector-status-error.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: cliffhall

clients/web/src/App.css

@@ -34,7 +34,7 @@
   --inspector-status-connected: var(--mantine-color-green-6);
   --inspector-status-connecting: var(--mantine-color-yellow-6);
   --inspector-status-disconnected: var(--mantine-color-gray-5);
-  --inspector-status-failed: var(--mantine-color-red-6);
+  --inspector-status-error: var(--mantine-color-red-6);
 
   /* ── Log levels (RFC 5424) ─────────────────────────────── */
   --inspector-log-debug: var(--mantine-color-gray-6);

clients/web/src/components/elements/AnnotationBadge/AnnotationBadge.stories.tsx

@@ -11,42 +11,63 @@ type Story = StoryObj<typeof AnnotationBadge>;
 
 export const Audience: Story = {
   args: {
-    label: "user",
-    variant: "audience",
+    facet: "audience",
+    value: ["user"],
+  },
+};
+
+export const AudienceMultiple: Story = {
+  args: {
+    facet: "audience",
+    value: ["user", "assistant"],
   },
 };
 
 export const ReadOnly: Story = {
   args: {
-    label: "read-only",
-    variant: "readOnly",
+    facet: "readOnlyHint",
+    value: true,
   },
 };
 
 export const Destructive: Story = {
   args: {
-    label: "destructive",
-    variant: "destructive",
+    facet: "destructiveHint",
+    value: true,
+  },
+};
+
+export const Idempotent: Story = {
+  args: {
+    facet: "idempotentHint",
+    value: true,
+  },
+};
+
+export const OpenWorld: Story = {
+  args: {
+    facet: "openWorldHint",
+    value: true,
   },
 };
 
-export const LongRun: Story = {
+export const LongRunning: Story = {
   args: {
-    label: "long-run",
-    variant: "longRun",
+    facet: "longRunHint",
+    value: true,
   },
 };
 
 export const PriorityHigh: Story = {
   args: {
-    label: "priority: high",
-    variant: "priority",
+    facet: "priority",
+    value: 0.9,
   },
 };
 
-export const Default: Story = {
+export const PriorityLow: Story = {
   args: {
-    label: "custom",
-    variant: "default",
+    facet: "priority",
+    value: 0.2,
   },
 };

clients/web/src/components/elements/AnnotationBadge/AnnotationBadge.tsx

@@ -1,37 +1,59 @@
 import { Badge, useComputedColorScheme } from "@mantine/core";
+import type { Role } from "@modelcontextprotocol/sdk/types.js";
 
-export type AnnotationVariant =
+export type AnnotationFacet =
   | "audience"
-  | "readOnly"
-  | "destructive"
-  | "longRun"
   | "priority"
-  | "default";
+  | "readOnlyHint"
+  | "destructiveHint"
+  | "idempotentHint"
+  | "openWorldHint"
+  | "longRunHint";
 
 export interface AnnotationBadgeProps {
-  label: string;
-  variant?: AnnotationVariant;
+  facet: AnnotationFacet;
+  value: Role[] | number | boolean;
 }
 
-const colorMap: Record<AnnotationVariant, string> = {
+const colorMap: Record<AnnotationFacet, string> = {
   audience: "blue",
-  readOnly: "green",
-  destructive: "red",
-  longRun: "yellow",
   priority: "orange",
-  default: "gray",
+  readOnlyHint: "green",
+  destructiveHint: "red",
+  idempotentHint: "teal",
+  openWorldHint: "grape",
+  longRunHint: "yellow",
 };
 
-export function AnnotationBadge({
-  label,
-  variant = "default",
-}: AnnotationBadgeProps) {
+function formatLabel(
+  facet: AnnotationFacet,
+  value: Role[] | number | boolean,
+): string {
+  switch (facet) {
+    case "audience":
+      return `audience: ${(value as Role[]).join(", ")}`;
+    case "priority":
+      return `priority: ${value}`;
+    case "readOnlyHint":
+      return "read-only";
+    case "destructiveHint":
+      return "destructive";
+    case "idempotentHint":
+      return "idempotent";
+    case "openWorldHint":
+      return "open-world";
+    case "longRunHint":
+      return "long-running";
+  }
+}
+
+export function AnnotationBadge({ facet, value }: AnnotationBadgeProps) {
   const colorScheme = useComputedColorScheme();
-  const color = colorMap[variant];
+  const color = colorMap[facet];
   const textColor = colorScheme === "dark" ? "black" : "white";
   return (
     <Badge color={color} variant="filled" fw={500} c={textColor}>
-      {label}
+      {formatLabel(facet, value)}
     </Badge>
   );
 }

clients/web/src/components/elements/CapabilityItem/CapabilityItem.stories.tsx

@@ -11,22 +11,22 @@ type Story = StoryObj<typeof CapabilityItem>;
 
 export const Supported: Story = {
   args: {
-    name: "Tools",
+    capability: "tools",
     supported: true,
   },
 };
 
 export const SupportedWithCount: Story = {
   args: {
-    name: "Tools",
+    capability: "tools",
     supported: true,
     count: 4,
   },
 };
 
 export const NotSupported: Story = {
   args: {
-    name: "Completions",
+    capability: "completions",
     supported: false,
   },
 };

clients/web/src/components/elements/CapabilityItem/CapabilityItem.tsx

@@ -1,16 +1,36 @@
 import { Group, Text } from "@mantine/core";
+import type {
+  ClientCapabilities,
+  ServerCapabilities,
+} from "@modelcontextprotocol/sdk/types.js";
+
+export type CapabilityKey = keyof ServerCapabilities | keyof ClientCapabilities;
 
 export interface CapabilityItemProps {
-  name: string;
+  capability: CapabilityKey;
   supported: boolean;
   count?: number;
 }
 
+const displayLabel: Record<string, string> = {
+  tools: "Tools",
+  resources: "Resources",
+  prompts: "Prompts",
+  logging: "Logging",
+  completions: "Completions",
+  tasks: "Tasks",
+  experimental: "Experimental",
+  roots: "Roots",
+  sampling: "Sampling",
+  elicitation: "Elicitation",
+};
+
 export function CapabilityItem({
-  name,
+  capability,
   supported,
   count,
 }: CapabilityItemProps) {
+  const name = displayLabel[capability] ?? String(capability);
   const label = count != null ? `${name} (${count})` : name;
 
   return (

clients/web/src/components/elements/ConnectionToggle/ConnectionToggle.stories.tsx

@@ -6,7 +6,8 @@ const meta: Meta<typeof ConnectionToggle> = {
   title: "Elements/ConnectionToggle",
   component: ConnectionToggle,
   args: {
-    onChange: fn(),
+    onConnect: fn(),
+    onDisconnect: fn(),
   },
 };
 
@@ -15,32 +16,31 @@ type Story = StoryObj<typeof ConnectionToggle>;
 
 export const Connected: Story = {
   args: {
-    checked: true,
-    loading: false,
-    disabled: false,
+    status: "connected",
   },
 };
 
 export const Disconnected: Story = {
   args: {
-    checked: false,
-    loading: false,
-    disabled: false,
+    status: "disconnected",
   },
 };
 
-export const Loading: Story = {
+export const Connecting: Story = {
   args: {
-    checked: false,
-    loading: true,
-    disabled: false,
+    status: "connecting",
   },
 };
 
 export const Disabled: Story = {
   args: {
-    checked: false,
-    loading: false,
+    status: "disconnected",
     disabled: true,
   },
 };
+
+export const Error: Story = {
+  args: {
+    status: "error",
+  },
+};

clients/web/src/components/elements/ConnectionToggle/ConnectionToggle.tsx

@@ -1,24 +1,34 @@
 import { Switch } from "@mantine/core";
+import type { ConnectionStatus } from "@inspector/core/mcp/types.js";
 
 export interface ConnectionToggleProps {
-  checked: boolean;
-  loading: boolean;
-  disabled: boolean;
-  onChange: (checked: boolean) => void;
+  status: ConnectionStatus;
+  disabled?: boolean;
+  onConnect: () => void;
+  onDisconnect: () => void;
 }
 
 export function ConnectionToggle({
-  checked,
-  loading,
-  disabled,
-  onChange,
+  status,
+  disabled = false,
+  onConnect,
+  onDisconnect,
 }: ConnectionToggleProps) {
+  const isConnected = status === "connected";
+  const isConnecting = status === "connecting";
+
   return (
     <Switch
       size="lg"
-      checked={checked || loading}
-      disabled={disabled || loading}
-      onChange={(event) => onChange(event.currentTarget.checked)}
+      checked={isConnected || isConnecting}
+      disabled={disabled || isConnecting}
+      onChange={(event) => {
+        if (event.currentTarget.checked) {
+          onConnect();
+        } else {
+          onDisconnect();
+        }
+      }}
     />
   );
 }