@tonyclaw/agent-inspector 2.0.10 → 2.0.12

package/src/components/proxy-viewer/anatomy/RequestAnatomy.tsx

@@ -1,6 +1,6 @@
-import { Info } from "lucide-react";
+import { ChevronDown, ChevronRight, Info } from "lucide-react";
 import { type JSX, useMemo, useState } from "react";
-import { cn, formatTokens } from "../../../lib/utils";
+import { cn, formatContextWindowTokens, formatTokens } from "../../../lib/utils";
 import { useProviders } from "../../../lib/useProviders";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "../../ui/tooltip";
 import {
@@ -9,6 +9,8 @@ import {
   type ContextDiagnostic,
   type DuplicateContextGroup,
   type DuplicateContextSegment,
+  type ContextHealth,
+  type ContextHealthLevel,
   type ContextIntelligence,
   type ContextRiskLevel,
 } from "./contextIntelligence";
@@ -63,6 +65,18 @@ const RISK_TEXT_CLASS: Record<ContextRiskLevel, string> = {
   danger: "text-red-300",
 };
 
+const HEALTH_BADGE_CLASS: Record<ContextHealthLevel, string> = {
+  ok: "border-emerald-400/30 bg-emerald-400/8 text-emerald-200",
+  optimizable: "border-amber-400/30 bg-amber-400/8 text-amber-100",
+  risk: "border-red-400/35 bg-red-500/10 text-red-100",
+};
+
+const HEALTH_LABEL: Record<ContextHealthLevel, string> = {
+  ok: "OK",
+  optimizable: "Optimizable",
+  risk: "Risk",
+};
+
 function formatPercent(value: number): string {
   if (value >= 10) return `${value.toFixed(0)}%`;
   if (value >= 1) return `${value.toFixed(1)}%`;
@@ -83,7 +97,7 @@ function formatRemainingTokens(value: number | null): string {
 
 function formatContextLimit(intelligence: ContextIntelligence): string {
   if (intelligence.contextWindow.tokens === null) return "Unknown";
-  return formatTokens(intelligence.contextWindow.tokens);
+  return formatContextWindowTokens(intelligence.contextWindow.tokens);
 }
 
 function formatContextSource(intelligence: ContextIntelligence): string {
@@ -110,6 +124,33 @@ function diagnosticTone(diagnostic: ContextDiagnostic): string {
   }
 }
 
+function formatContextHealth(health: ContextHealth): string {
+  const label = HEALTH_LABEL[health.level];
+  if (health.level === "ok") return label;
+  const countLabel =
+    health.level === "risk"
+      ? `${String(health.opportunityCount)} signal${health.opportunityCount === 1 ? "" : "s"}`
+      : `${String(health.opportunityCount)} opportunit${
+          health.opportunityCount === 1 ? "y" : "ies"
+        }`;
+  if (health.reclaimableTokens <= 0) return `${label} | ${countLabel}`;
+  return `${label} | ${countLabel} | ~${formatTokens(health.reclaimableTokens)} tokens`;
+}
+
+function ContextHealthBadge({ health }: { health: ContextHealth }): JSX.Element {
+  return (
+    <span
+      className={cn(
+        "inline-flex h-5 max-w-full items-center rounded border px-1.5 font-mono text-[10px]",
+        HEALTH_BADGE_CLASS[health.level],
+      )}
+      aria-label={`Context health ${formatContextHealth(health)}`}
+    >
+      <span className="truncate">{formatContextHealth(health)}</span>
+    </span>
+  );
+}
+
 function ContextIntelligenceStrip({
   intelligence,
 }: {
@@ -243,6 +284,8 @@ function DuplicateContentPanel({
   segments: readonly AnatomySegment[];
   onSegmentActivate?: (segment: AnatomySegment) => void;
 }): JSX.Element | null {
+  const [expanded, setExpanded] = useState(false);
+
   if (groups.length === 0) return null;
 
   const visibleGroups = groups.slice(0, DUPLICATE_GROUP_DISPLAY_COUNT);
@@ -251,87 +294,105 @@ function DuplicateContentPanel({
 
   return (
     <section className="space-y-2 rounded border border-border/70 bg-muted/15 p-2">
-      <div className="flex flex-wrap items-center justify-between gap-2">
-        <div className="text-xs font-medium text-foreground">Duplicate Content</div>
-        <div className="font-mono text-[11px] text-muted-foreground">
+      <button
+        type="button"
+        onClick={() => setExpanded((current) => !current)}
+        aria-expanded={expanded}
+        className="flex w-full flex-wrap items-center justify-between gap-2 rounded px-1 py-0.5 text-left transition-colors hover:bg-muted/30 focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-1"
+      >
+        <span className="inline-flex min-w-0 items-center gap-1.5">
+          {expanded ? (
+            <ChevronDown className="size-3.5 shrink-0 text-muted-foreground" />
+          ) : (
+            <ChevronRight className="size-3.5 shrink-0 text-muted-foreground" />
+          )}
+          <span className="truncate text-xs font-medium text-foreground">Duplicate Content</span>
+        </span>
+        <span className="font-mono text-[11px] text-muted-foreground">
           {String(groups.length)} group{groups.length === 1 ? "" : "s"} | ~
           {formatTokens(totalRepeatedTokens)} repeated
-        </div>
-      </div>
-
-      <div className="space-y-2">
-        {visibleGroups.map((group, groupIndex) => {
-          const visibleSegments = group.segments.slice(0, DUPLICATE_SEGMENT_DISPLAY_COUNT);
-          const hiddenSegmentCount = group.segments.length - visibleSegments.length;
-          return (
-            <div
-              key={group.key}
-              className="space-y-1.5 border-t border-border/50 pt-2 first:border-t-0 first:pt-0"
-            >
-              <div className="flex min-w-0 items-center gap-2 text-xs">
-                <span className="w-5 shrink-0 text-right font-mono text-muted-foreground/70">
-                  {String(groupIndex + 1)}
-                </span>
-                <span className="min-w-0 flex-1 truncate text-foreground">{group.firstLabel}</span>
-                <span className="shrink-0 font-mono text-muted-foreground">
-                  x{String(group.count)} | ~{formatTokens(group.repeatedTokens)} saved
-                </span>
-              </div>
+        </span>
+      </button>
+
+      {expanded && (
+        <>
+          <div className="space-y-2">
+            {visibleGroups.map((group, groupIndex) => {
+              const visibleSegments = group.segments.slice(0, DUPLICATE_SEGMENT_DISPLAY_COUNT);
+              const hiddenSegmentCount = group.segments.length - visibleSegments.length;
+              return (
+                <div
+                  key={group.key}
+                  className="space-y-1.5 border-t border-border/50 pt-2 first:border-t-0 first:pt-0"
+                >
+                  <div className="flex min-w-0 items-center gap-2 text-xs">
+                    <span className="w-5 shrink-0 text-right font-mono text-muted-foreground/70">
+                      {String(groupIndex + 1)}
+                    </span>
+                    <span className="min-w-0 flex-1 truncate text-foreground">
+                      {group.firstLabel}
+                    </span>
+                    <span className="shrink-0 font-mono text-muted-foreground">
+                      x{String(group.count)} | ~{formatTokens(group.repeatedTokens)} saved
+                    </span>
+                  </div>
+
+                  {group.preview.length > 0 && (
+                    <div className="ml-7 line-clamp-2 break-words rounded bg-background/40 px-2 py-1 font-mono text-[11px] leading-4 text-muted-foreground">
+                      {group.preview}
+                    </div>
+                  )}
 
-              {group.preview.length > 0 && (
-                <div className="ml-7 line-clamp-2 break-words rounded bg-background/40 px-2 py-1 font-mono text-[11px] leading-4 text-muted-foreground">
-                  {group.preview}
-                </div>
-              )}
-
-              <div className="ml-7 flex flex-wrap gap-1">
-                {visibleSegments.map((duplicateSegment, segmentIndex) => {
-                  const target = resolveDuplicateSegment(duplicateSegment, segments);
-                  const activate =
-                    target === null || onSegmentActivate === undefined
-                      ? undefined
-                      : onSegmentActivate;
-                  const label = `${duplicateSegment.label} ~${formatTokens(
-                    duplicateSegment.tokens,
-                  )}`;
-                  if (activate === undefined || target === null) {
-                    return (
-                      <span
-                        key={`${duplicateSegment.path}-${segmentIndex}`}
-                        className="inline-flex h-6 max-w-40 items-center rounded border border-border/60 px-1.5 text-[11px] text-muted-foreground"
-                        title={label}
-                      >
-                        <span className="truncate">{label}</span>
+                  <div className="ml-7 flex flex-wrap gap-1">
+                    {visibleSegments.map((duplicateSegment, segmentIndex) => {
+                      const target = resolveDuplicateSegment(duplicateSegment, segments);
+                      const activate =
+                        target === null || onSegmentActivate === undefined
+                          ? undefined
+                          : onSegmentActivate;
+                      const label = `${duplicateSegment.label} ~${formatTokens(
+                        duplicateSegment.tokens,
+                      )}`;
+                      if (activate === undefined || target === null) {
+                        return (
+                          <span
+                            key={`${duplicateSegment.path}-${segmentIndex}`}
+                            className="inline-flex h-6 max-w-40 items-center rounded border border-border/60 px-1.5 text-[11px] text-muted-foreground"
+                            title={label}
+                          >
+                            <span className="truncate">{label}</span>
+                          </span>
+                        );
+                      }
+                      return (
+                        <button
+                          key={`${duplicateSegment.path}-${segmentIndex}`}
+                          type="button"
+                          onClick={() => activate(target)}
+                          className="inline-flex h-6 max-w-40 items-center rounded border border-border/60 px-1.5 text-[11px] text-muted-foreground hover:border-border hover:bg-muted/40 hover:text-foreground"
+                          title="Jump to this duplicate block"
+                        >
+                          <span className="truncate">{label}</span>
+                        </button>
+                      );
+                    })}
+                    {hiddenSegmentCount > 0 && (
+                      <span className="inline-flex h-6 items-center rounded border border-border/40 px-1.5 font-mono text-[11px] text-muted-foreground/70">
+                        +{String(hiddenSegmentCount)}
                       </span>
-                    );
-                  }
-                  return (
-                    <button
-                      key={`${duplicateSegment.path}-${segmentIndex}`}
-                      type="button"
-                      onClick={() => activate(target)}
-                      className="inline-flex h-6 max-w-40 items-center rounded border border-border/60 px-1.5 text-[11px] text-muted-foreground hover:border-border hover:bg-muted/40 hover:text-foreground"
-                      title="Jump to this duplicate block"
-                    >
-                      <span className="truncate">{label}</span>
-                    </button>
-                  );
-                })}
-                {hiddenSegmentCount > 0 && (
-                  <span className="inline-flex h-6 items-center rounded border border-border/40 px-1.5 font-mono text-[11px] text-muted-foreground/70">
-                    +{String(hiddenSegmentCount)}
-                  </span>
-                )}
-              </div>
-            </div>
-          );
-        })}
-      </div>
+                    )}
+                  </div>
+                </div>
+              );
+            })}
+          </div>
 
-      {hiddenGroupCount > 0 && (
-        <div className="border-t border-border/50 pt-2 font-mono text-[11px] text-muted-foreground">
-          +{String(hiddenGroupCount)} more duplicate group{hiddenGroupCount === 1 ? "" : "s"}
-        </div>
+          {hiddenGroupCount > 0 && (
+            <div className="border-t border-border/50 pt-2 font-mono text-[11px] text-muted-foreground">
+              +{String(hiddenGroupCount)} more duplicate group{hiddenGroupCount === 1 ? "" : "s"}
+            </div>
+          )}
+        </>
       )}
     </section>
   );
@@ -437,7 +498,10 @@ export function RequestAnatomy({
       <div className="px-4 py-3 space-y-3" data-testid="anatomy-root">
         <div className="flex flex-wrap items-start justify-between gap-3">
           <div className="min-w-0">
-            <div className="text-sm font-semibold text-foreground">Request Context</div>
+            <div className="flex min-w-0 flex-wrap items-center gap-2">
+              <div className="text-sm font-semibold text-foreground">Request Context</div>
+              {intelligence !== null && <ContextHealthBadge health={intelligence.health} />}
+            </div>
             <div className={cn("mt-0.5 text-xs font-mono tabular-nums", summaryColorClass)}>
               Estimated ~{formatTokens(total)} tokens | {providerInputLabel} | {contextLimitLabel} |{" "}
               {usageLabel} | {segmentCountLabel}

package/src/components/proxy-viewer/anatomy/contextIntelligence.ts

@@ -8,6 +8,8 @@ export type ContextRiskLevel = "unknown" | "ok" | "watch" | "danger";
 
 export type ContextWindowSource = "request" | "provider" | "model-rule" | "unknown";
 
+export type ContextHealthLevel = "ok" | "optimizable" | "risk";
+
 export type ContextWindow = {
   tokens: number | null;
   label: string;
@@ -46,6 +48,12 @@ export type DuplicateContextGroup = {
   segments: DuplicateContextSegment[];
 };
 
+export type ContextHealth = {
+  level: ContextHealthLevel;
+  opportunityCount: number;
+  reclaimableTokens: number;
+};
+
 export type ContextIntelligence = {
   model: string | null;
   contextWindow: ContextWindow;
@@ -60,6 +68,7 @@ export type ContextIntelligence = {
   largestRole: RoleUsage | null;
   diagnostics: ContextDiagnostic[];
   duplicateGroups: DuplicateContextGroup[];
+  health: ContextHealth;
 };
 
 type MatchMode = "prefix" | "includes";
@@ -158,7 +167,7 @@ const MODEL_CONTEXT_RULES: readonly ModelContextRule[] = [
   },
   {
     family: "DeepSeek V4",
-    tokens: 1_000_000,
+    tokens: 1_048_576,
     mode: "prefix",
     patterns: ["deepseek-v4-pro", "deepseek-v4-flash"],
   },
@@ -170,15 +179,33 @@ const MODEL_CONTEXT_RULES: readonly ModelContextRule[] = [
   },
   {
     family: "MiniMax M3",
-    tokens: 1_000_000,
+    tokens: 1_048_576,
     mode: "includes",
     patterns: ["minimax-m3"],
   },
   {
-    family: "MiniMax M2",
+    family: "MiniMax M2.7",
     tokens: 204_800,
     mode: "includes",
-    patterns: ["minimax-m2.7", "minimax-m2.5", "minimax-m2.1"],
+    patterns: ["minimax-m2.7"],
+  },
+  {
+    family: "MiniMax M2.5/M2.1",
+    tokens: 196_608,
+    mode: "includes",
+    patterns: ["minimax-m2.5", "minimax-m2.1"],
+  },
+  {
+    family: "GLM-5.2",
+    tokens: 1_048_576,
+    mode: "prefix",
+    patterns: ["glm-5.2"],
+  },
+  {
+    family: "GLM-5",
+    tokens: 202_752,
+    mode: "prefix",
+    patterns: ["glm-5", "glm-5.1"],
   },
 ];
 
@@ -551,6 +578,10 @@ function duplicateDiagnostic(
   };
 }
 
+function duplicateReclaimableTokens(duplicateGroups: readonly DuplicateContextGroup[]): number {
+  return duplicateGroups.reduce((sum, group) => sum + group.repeatedTokens, 0);
+}
+
 function diagnosticsForRolePressure(
   roleUsages: readonly RoleUsage[],
   total: number,
@@ -606,6 +637,33 @@ function diagnosticsForRolePressure(
   return diagnostics;
 }
 
+function contextHealth({
+  risk,
+  contextWindow,
+  diagnostics,
+  duplicateGroups,
+}: {
+  risk: ContextRiskLevel;
+  contextWindow: ContextWindow;
+  diagnostics: readonly ContextDiagnostic[];
+  duplicateGroups: readonly DuplicateContextGroup[];
+}): ContextHealth {
+  const diagnosticKinds = new Set(diagnostics.map((diagnostic) => diagnostic.kind));
+  let opportunityCount = diagnosticKinds.size;
+  if (risk === "watch" || risk === "danger") opportunityCount += 1;
+  if (contextWindow.source === "unknown") opportunityCount += 1;
+
+  const hasDangerDiagnostic = diagnostics.some((diagnostic) => diagnostic.severity === "danger");
+  const level: ContextHealthLevel =
+    risk === "danger" || hasDangerDiagnostic ? "risk" : opportunityCount > 0 ? "optimizable" : "ok";
+
+  return {
+    level,
+    opportunityCount,
+    reclaimableTokens: duplicateReclaimableTokens(duplicateGroups),
+  };
+}
+
 export function analyzeContextIntelligence({
   segments,
   inputTokens,
@@ -648,6 +706,7 @@ export function analyzeContextIntelligence({
     messageSegmentCount,
   );
   if (duplicate !== null) diagnostics.unshift(duplicate);
+  const risk = riskLevel(usagePercent);
 
   return {
     model: requestModel,
@@ -658,11 +717,17 @@ export function analyzeContextIntelligence({
     remainingInputTokens,
     remainingAfterReserveTokens,
     usagePercent,
-    riskLevel: riskLevel(usagePercent),
+    riskLevel: risk,
     roleUsages,
     largestRole,
     diagnostics,
     duplicateGroups,
+    health: contextHealth({
+      risk,
+      contextWindow,
+      diagnostics,
+      duplicateGroups,
+    }),
   };
 }
 

package/src/components/proxy-viewer/anatomy/sessionContextSummary.ts

@@ -0,0 +1,196 @@
+import type { ProviderConfig } from "../../../lib/providerContract";
+import type { CapturedLog } from "../../../proxy/schemas";
+import { getLogFormatAdapter, resolveLogFormat } from "../log-formats";
+import {
+  analyzeContextIntelligence,
+  type ContextHealth,
+  type ContextRiskLevel,
+  type ContextWindow,
+  type RoleUsage,
+} from "./contextIntelligence";
+import type { AnatomySegment } from "./types";
+
+export type SessionContextSnapshot = {
+  logId: number;
+  model: string;
+  timestamp: string;
+  contextWindow: ContextWindow;
+  estimatedInputTokens: number;
+  windowUsedTokens: number | null;
+  usagePercent: number | null;
+  riskLevel: ContextRiskLevel;
+  health: ContextHealth;
+  diagnostics: string[];
+  roleSegments: AnatomySegment[];
+  roleTotalTokens: number;
+};
+
+export type SessionModelContextSummary = {
+  model: string;
+  requestCount: number;
+  first: SessionContextSnapshot;
+  latest: SessionContextSnapshot;
+  peak: SessionContextSnapshot;
+  trendPercent: number | null;
+};
+
+export type SessionContextSummary = {
+  models: SessionModelContextSummary[];
+};
+
+type SummaryAccumulator = {
+  model: string;
+  requestCount: number;
+  first: SessionContextSnapshot;
+  latest: SessionContextSnapshot;
+  peak: SessionContextSnapshot;
+};
+
+function parseRequestBody(rawBody: string | null): unknown | null {
+  if (rawBody === null) return null;
+  try {
+    const parsed: unknown = JSON.parse(rawBody);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function roleUsageSegment(usage: RoleUsage): AnatomySegment {
+  return {
+    role: usage.role,
+    label: usage.label,
+    size: usage.tokens,
+    characters: usage.tokens * 4,
+    text: "",
+    path: `role:${usage.role}`,
+  };
+}
+
+function snapshotFromLog(
+  log: CapturedLog,
+  providers: readonly ProviderConfig[],
+): SessionContextSnapshot | null {
+  const parsed = parseRequestBody(log.rawRequestBody);
+  if (parsed === null) return null;
+
+  const adapter = getLogFormatAdapter(resolveLogFormat(log));
+  const segments = adapter.anatomySegments(parsed);
+  if (segments === null) return null;
+
+  const intelligence = analyzeContextIntelligence({
+    segments,
+    inputTokens: log.inputTokens ?? null,
+    parsed,
+    model: log.model,
+    providers,
+  });
+  const model = intelligence.model ?? log.model ?? "Unknown model";
+  const roleSegments = intelligence.roleUsages.map(roleUsageSegment);
+
+  return {
+    logId: log.id,
+    model,
+    timestamp: log.timestamp,
+    contextWindow: intelligence.contextWindow,
+    estimatedInputTokens: intelligence.estimatedInputTokens,
+    windowUsedTokens: intelligence.windowUsedTokens,
+    usagePercent: intelligence.usagePercent,
+    riskLevel: intelligence.riskLevel,
+    health: intelligence.health,
+    diagnostics: intelligence.diagnostics.map((diagnostic) => diagnostic.title),
+    roleSegments,
+    roleTotalTokens: roleSegments.reduce((sum, segment) => sum + segment.size, 0),
+  };
+}
+
+function isHigherPeak(candidate: SessionContextSnapshot, current: SessionContextSnapshot): boolean {
+  if (candidate.usagePercent !== null && current.usagePercent !== null) {
+    return candidate.usagePercent > current.usagePercent;
+  }
+  if (candidate.usagePercent !== null && current.usagePercent === null) return true;
+  if (candidate.usagePercent === null && current.usagePercent !== null) return false;
+  return candidate.estimatedInputTokens > current.estimatedInputTokens;
+}
+
+function riskRank(risk: ContextRiskLevel): number {
+  switch (risk) {
+    case "danger":
+      return 4;
+    case "watch":
+      return 3;
+    case "unknown":
+      return 2;
+    case "ok":
+      return 1;
+  }
+}
+
+function compareModelSummary(
+  left: SessionModelContextSummary,
+  right: SessionModelContextSummary,
+): number {
+  const riskDelta = riskRank(right.latest.riskLevel) - riskRank(left.latest.riskLevel);
+  if (riskDelta !== 0) return riskDelta;
+
+  const leftPeak = left.peak.usagePercent ?? -1;
+  const rightPeak = right.peak.usagePercent ?? -1;
+  const peakDelta = rightPeak - leftPeak;
+  if (peakDelta !== 0) return peakDelta;
+
+  return right.latest.logId - left.latest.logId;
+}
+
+function trendPercent(
+  first: SessionContextSnapshot,
+  latest: SessionContextSnapshot,
+): number | null {
+  if (first.usagePercent === null || latest.usagePercent === null) return null;
+  return (latest.usagePercent - first.usagePercent) * 100;
+}
+
+export function buildSessionContextSummary(
+  logs: readonly CapturedLog[],
+  providers: readonly ProviderConfig[] = [],
+): SessionContextSummary {
+  const sortedLogs = [...logs].sort((left, right) => left.id - right.id);
+  const byModel = new Map<string, SummaryAccumulator>();
+
+  for (const log of sortedLogs) {
+    const snapshot = snapshotFromLog(log, providers);
+    if (snapshot === null) continue;
+
+    const existing = byModel.get(snapshot.model);
+    if (existing === undefined) {
+      byModel.set(snapshot.model, {
+        model: snapshot.model,
+        requestCount: 1,
+        first: snapshot,
+        latest: snapshot,
+        peak: snapshot,
+      });
+      continue;
+    }
+
+    byModel.set(snapshot.model, {
+      model: existing.model,
+      requestCount: existing.requestCount + 1,
+      first: existing.first,
+      latest: snapshot,
+      peak: isHigherPeak(snapshot, existing.peak) ? snapshot : existing.peak,
+    });
+  }
+
+  const models = [...byModel.values()]
+    .map((entry) => ({
+      model: entry.model,
+      requestCount: entry.requestCount,
+      first: entry.first,
+      latest: entry.latest,
+      peak: entry.peak,
+      trendPercent: trendPercent(entry.first, entry.latest),
+    }))
+    .sort(compareModelSummary);
+
+  return { models };
+}

package/src/components/proxy-viewer/logFocus.ts

@@ -0,0 +1,33 @@
+import { safeGetOwnProperty } from "../../lib/objectUtils";
+
+export const LOG_FOCUS_REQUEST_EVENT = "agent-inspector:focus-log";
+
+export type LogFocusTab = "anatomy" | "request";
+
+export type LogFocusRequest = {
+  logId: number;
+  tab: LogFocusTab;
+};
+
+export function dispatchLogFocusRequest(request: LogFocusRequest): void {
+  window.dispatchEvent(new CustomEvent(LOG_FOCUS_REQUEST_EVENT, { detail: request }));
+}
+
+export function readLogFocusRequest(event: Event): LogFocusRequest | null {
+  if (typeof CustomEvent === "undefined" || !(event instanceof CustomEvent)) return null;
+
+  const detail: unknown = event.detail;
+  const logId = safeGetOwnProperty(detail, "logId");
+  if (typeof logId !== "number" || !Number.isInteger(logId) || logId < 0) return null;
+
+  const tab = safeGetOwnProperty(detail, "tab");
+  switch (tab) {
+    case "anatomy":
+    case "request":
+      return { logId, tab };
+    case undefined:
+      return { logId, tab: "request" };
+    default:
+      return null;
+  }
+}