@tonyclaw/agent-inspector 2.0.8 → 2.0.10

package/.output/server/_ssr/{RequestAnatomy-DaQjhixp.mjs → RequestAnatomy-D1X3f3AX.mjs}

@@ -1,6 +1,6 @@
 import { r as reactExports, j as jsxRuntimeExports } from "../_libs/react.mjs";
-import { f as formatTokens, k as TooltipProvider, c as cn, l as Tooltip, m as TooltipTrigger, n as TooltipContent } from "./ProxyViewerContainer-DiZjOTQT.mjs";
-import { s as safeGetOwnProperty } from "./router-Bf0m6F0G.mjs";
+import { u as useProviders, f as formatTokens, k as TooltipProvider, c as cn, l as Tooltip, m as TooltipTrigger, n as TooltipContent, p as countCharacters, q as estimateTokens } from "./ProxyViewerContainer-DrSMa5O7.mjs";
+import { s as safeGetOwnProperty, k as resolveProviderContextWindow, l as isPlainRecord } from "./router-CSRaa_tu.mjs";
 import "../_libs/jszip.mjs";
 import "../_libs/modelcontextprotocol__server.mjs";
 import { aa as Info } from "../_libs/lucide-react.mjs";
@@ -171,11 +171,30 @@ const LONG_TOOL_SCHEMA_TOKENS = 8e3;
 const LARGE_ROLE_PERCENT = 0.35;
 const DUPLICATE_MIN_TOKENS = 40;
 const DUPLICATE_MIN_CHARS = 160;
+const DUPLICATE_NESTED_MAX_DEPTH = 5;
+const DUPLICATE_NESTED_MAX_CANDIDATES_PER_SEGMENT = 8;
 const HISTORY_BLOAT_SEGMENTS = 18;
 const HISTORY_BLOAT_TOKENS = 6e4;
 const HISTORY_BLOAT_PERCENT = 0.7;
 const SYSTEM_HEAVY_TOKENS = 3e3;
 const SYSTEM_HEAVY_PERCENT = 0.3;
+const DUPLICATE_PREVIEW_CHARS = 160;
+const DUPLICATE_NESTED_FIELD_NAMES = /* @__PURE__ */ new Set([
+  "answer",
+  "body",
+  "content",
+  "data",
+  "error",
+  "message",
+  "markdown",
+  "output",
+  "response",
+  "result",
+  "stderr",
+  "stdout",
+  "text",
+  "transcript"
+]);
 const EXPLICIT_CONTEXT_WINDOW_FIELDS = [
   "context_window",
   "contextWindow",
@@ -219,6 +238,12 @@ const MODEL_CONTEXT_RULES = [
     mode: "prefix",
     patterns: ["claude-"]
   },
+  {
+    family: "DeepSeek V4",
+    tokens: 1e6,
+    mode: "prefix",
+    patterns: ["deepseek-v4-pro", "deepseek-v4-flash"]
+  },
   {
     family: "DeepSeek",
     tokens: 64e3,
@@ -226,10 +251,16 @@ const MODEL_CONTEXT_RULES = [
     patterns: ["deepseek-"]
   },
   {
-    family: "MiniMax",
+    family: "MiniMax M3",
     tokens: 1e6,
     mode: "includes",
-    patterns: ["minimax"]
+    patterns: ["minimax-m3"]
+  },
+  {
+    family: "MiniMax M2",
+    tokens: 204800,
+    mode: "includes",
+    patterns: ["minimax-m2.7", "minimax-m2.5", "minimax-m2.1"]
   }
 ];
 const ROLE_LABELS = {
@@ -271,7 +302,7 @@ function matchesRule(model, rule) {
       return rule.patterns.some((pattern) => model.includes(pattern));
   }
 }
-function resolveContextWindow(model, parsed) {
+function resolveContextWindow(model, parsed, providers = []) {
   const explicitWindow = readPositiveIntegerField(parsed, EXPLICIT_CONTEXT_WINDOW_FIELDS);
   if (explicitWindow !== null) {
     return {
@@ -280,6 +311,14 @@ function resolveContextWindow(model, parsed) {
       source: "request"
     };
   }
+  const providerWindow = resolveProviderContextWindow(model, providers);
+  if (providerWindow !== null) {
+    return {
+      tokens: providerWindow.tokens,
+      label: `${providerWindow.providerName} config`,
+      source: "provider"
+    };
+  }
   if (model === null) {
     return {
       tokens: null,
@@ -287,12 +326,12 @@ function resolveContextWindow(model, parsed) {
       source: "unknown"
     };
   }
-  const normalized = model.trim().toLowerCase();
+  const normalized = model.trim().toLowerCase().replace(/\s+/g, "-");
   for (const rule of MODEL_CONTEXT_RULES) {
     if (matchesRule(normalized, rule)) {
       return {
         tokens: rule.tokens,
-        label: rule.family,
+        label: `${rule.family} local rule`,
         source: "model-rule"
       };
     }
@@ -332,42 +371,187 @@ function buildRoleUsages(segments, total) {
 function normalizeDuplicateText(text) {
   return text.replace(/\s+/g, " ").trim().toLowerCase();
 }
-function duplicateDiagnostic(segments) {
+function duplicatePreview(text) {
+  const singleLine = text.replace(/\s+/g, " ").trim();
+  if (singleLine.length <= DUPLICATE_PREVIEW_CHARS) return singleLine;
+  return `${singleLine.slice(0, DUPLICATE_PREVIEW_CHARS - 3)}...`;
+}
+function duplicateSegmentRef(candidate) {
+  return {
+    role: candidate.role,
+    label: candidate.label,
+    path: candidate.path,
+    tokens: candidate.tokens,
+    characters: candidate.characters
+  };
+}
+function duplicateCandidateFromSegment(segment) {
+  return {
+    role: segment.role,
+    label: segment.label,
+    path: segment.path,
+    tokens: segment.size,
+    characters: segment.characters,
+    text: segment.text
+  };
+}
+function jsonLikeText(text) {
+  const trimmed = text.trim();
+  return trimmed.startsWith("{") || trimmed.startsWith("[");
+}
+function parseJsonLikeText(text) {
+  if (!jsonLikeText(text)) return null;
+  try {
+    const parsed = JSON.parse(text);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function normalizePathFieldName(field) {
+  return field.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function lastNamedPathField(path) {
+  for (let index = path.length - 1; index >= 0; index -= 1) {
+    const field = path[index] ?? "";
+    if (field.startsWith("[") && field.endsWith("]")) continue;
+    return field;
+  }
+  return null;
+}
+function nestedDuplicateFieldPath(path) {
+  const field = lastNamedPathField(path);
+  if (field === null) return false;
+  return DUPLICATE_NESTED_FIELD_NAMES.has(normalizePathFieldName(field));
+}
+function formatNestedDuplicatePath(path) {
+  return path.map((part) => part.startsWith("[") ? part : `.${part}`).join("").replace(/^\./, "");
+}
+function duplicateCandidateFromNestedText(segment, text, path) {
+  const characters = countCharacters(text);
+  if (characters < DUPLICATE_MIN_CHARS) return null;
+  const tokens = estimateTokens(text);
+  if (tokens < DUPLICATE_MIN_TOKENS) return null;
+  return {
+    role: segment.role,
+    label: `${segment.label} ${formatNestedDuplicatePath(path)}`,
+    path: segment.path,
+    tokens,
+    characters,
+    text
+  };
+}
+function collectNestedDuplicateCandidates({
+  value,
+  segment,
+  path,
+  depth,
+  candidates
+}) {
+  if (candidates.length >= DUPLICATE_NESTED_MAX_CANDIDATES_PER_SEGMENT) return;
+  if (depth > DUPLICATE_NESTED_MAX_DEPTH) return;
+  if (typeof value === "string") {
+    if (!nestedDuplicateFieldPath(path)) return;
+    const candidate = duplicateCandidateFromNestedText(segment, value, path);
+    if (candidate !== null) candidates.push(candidate);
+    return;
+  }
+  if (Array.isArray(value)) {
+    value.forEach(
+      (item, index) => collectNestedDuplicateCandidates({
+        value: item,
+        segment,
+        path: [...path, `[${String(index)}]`],
+        depth: depth + 1,
+        candidates
+      })
+    );
+    return;
+  }
+  if (!isPlainRecord(value)) return;
+  Object.entries(value).forEach(
+    ([key, child]) => collectNestedDuplicateCandidates({
+      value: child,
+      segment,
+      path: [...path, key],
+      depth: depth + 1,
+      candidates
+    })
+  );
+}
+function duplicateCandidatesForSegment(segment) {
+  const segmentCandidate = duplicateCandidateFromSegment(segment);
+  const parsed = parseJsonLikeText(segment.text);
+  if (parsed === null) return [segmentCandidate];
+  const candidates = [];
+  collectNestedDuplicateCandidates({
+    value: parsed,
+    segment,
+    path: [],
+    depth: 0,
+    candidates
+  });
+  const normalizedSegment = normalizeDuplicateText(segment.text);
+  const seen = /* @__PURE__ */ new Set([normalizedSegment]);
+  const uniqueNested = candidates.filter((candidate) => {
+    const normalized = normalizeDuplicateText(candidate.text);
+    if (normalized === "") return false;
+    if (seen.has(normalized)) return false;
+    seen.add(normalized);
+    return true;
+  });
+  return [segmentCandidate, ...uniqueNested];
+}
+function duplicateContextGroups(segments) {
   const buckets = /* @__PURE__ */ new Map();
   for (const segment of segments) {
-    if (segment.size < DUPLICATE_MIN_TOKENS) continue;
-    if (segment.characters < DUPLICATE_MIN_CHARS) continue;
-    const normalized = normalizeDuplicateText(segment.text);
-    if (normalized === "") continue;
-    const existing = buckets.get(normalized);
-    if (existing === void 0) {
+    const candidates = duplicateCandidatesForSegment(segment);
+    for (const candidate of candidates) {
+      if (candidate.tokens < DUPLICATE_MIN_TOKENS) continue;
+      if (candidate.characters < DUPLICATE_MIN_CHARS) continue;
+      const normalized = normalizeDuplicateText(candidate.text);
+      if (normalized === "") continue;
+      const existing = buckets.get(normalized);
+      if (existing === void 0) {
+        buckets.set(normalized, {
+          tokens: candidate.tokens,
+          candidates: [candidate]
+        });
+        continue;
+      }
       buckets.set(normalized, {
-        count: 1,
-        tokens: segment.size,
-        firstTokens: segment.size,
-        label: segment.label
+        tokens: existing.tokens + candidate.tokens,
+        candidates: [...existing.candidates, candidate]
       });
-      continue;
     }
-    buckets.set(normalized, {
-      count: existing.count + 1,
-      tokens: existing.tokens + segment.size,
-      firstTokens: existing.firstTokens,
-      label: existing.label
-    });
   }
-  let repeatedGroups = 0;
-  let repeatedSegments = 0;
-  let repeatedTokens = 0;
-  let largest = null;
+  const groups = [];
   for (const bucket of buckets.values()) {
-    if (bucket.count < 2) continue;
-    repeatedGroups += 1;
-    repeatedSegments += bucket.count;
-    repeatedTokens += bucket.tokens - bucket.firstTokens;
-    if (largest === null || bucket.tokens > largest.tokens) largest = bucket;
+    if (bucket.candidates.length < 2) continue;
+    const firstCandidate = bucket.candidates[0] ?? null;
+    if (firstCandidate === null) continue;
+    const repeatedTokens = bucket.tokens - firstCandidate.tokens;
+    groups.push({
+      key: `${firstCandidate.path}:${firstCandidate.label}:${String(
+        bucket.candidates.length
+      )}:${String(bucket.tokens)}`,
+      count: bucket.candidates.length,
+      totalTokens: bucket.tokens,
+      repeatedTokens,
+      preview: duplicatePreview(firstCandidate.text),
+      firstLabel: firstCandidate.label,
+      segments: bucket.candidates.map(duplicateSegmentRef)
+    });
   }
-  if (repeatedGroups === 0 || largest === null) return null;
+  return groups.sort(
+    (left, right) => right.repeatedTokens - left.repeatedTokens || right.totalTokens - left.totalTokens
+  );
+}
+function duplicateDiagnostic(duplicateGroups) {
+  if (duplicateGroups.length === 0) return null;
+  const repeatedGroups = duplicateGroups.length;
+  const repeatedSegments = duplicateGroups.reduce((sum, group) => sum + group.count, 0);
+  const repeatedTokens = duplicateGroups.reduce((sum, group) => sum + group.repeatedTokens, 0);
   return {
     kind: "duplicate",
     severity: repeatedTokens >= LONG_TOOL_SCHEMA_TOKENS ? "danger" : "watch",
@@ -415,13 +599,14 @@ function analyzeContextIntelligence({
   segments,
   inputTokens,
   parsed,
-  model
+  model,
+  providers = []
 }) {
   const totalEstimatedTokens = segments.reduce((sum, segment) => sum + segment.size, 0);
   const requestModel = model ?? readRequestModel(parsed);
   const estimatedInputTokens = inputTokens ?? totalEstimatedTokens;
   const outputReserveTokens = readPositiveIntegerField(parsed, OUTPUT_RESERVE_FIELDS);
-  const contextWindow = resolveContextWindow(requestModel, parsed);
+  const contextWindow = resolveContextWindow(requestModel, parsed, providers);
   const reservedTokens = outputReserveTokens ?? 0;
   const windowUsedTokens = contextWindow.tokens === null ? null : estimatedInputTokens + reservedTokens;
   const remainingInputTokens = contextWindow.tokens === null ? null : contextWindow.tokens - estimatedInputTokens;
@@ -430,7 +615,8 @@ function analyzeContextIntelligence({
   const roleUsages = buildRoleUsages(segments, totalEstimatedTokens);
   const largestRole = roleUsages[0] ?? null;
   const messageSegmentCount = segments.filter((segment) => segment.role !== "tools").length;
-  const duplicate = duplicateDiagnostic(segments);
+  const duplicateGroups = duplicateContextGroups(segments);
+  const duplicate = duplicateDiagnostic(duplicateGroups);
   const diagnostics = diagnosticsForRolePressure(
     roleUsages,
     totalEstimatedTokens,
@@ -449,7 +635,8 @@ function analyzeContextIntelligence({
     riskLevel: riskLevel(usagePercent),
     roleUsages,
     largestRole,
-    diagnostics
+    diagnostics,
+    duplicateGroups
   };
 }
 const CONTEXT_USAGE_THRESHOLDS = {
@@ -662,6 +849,8 @@ const SegmentBar = reactExports.memo(function SegmentBar2({
 });
 const DIVERGENCE_AMBER_THRESHOLD = 0.25;
 const TOP_CONTRIBUTOR_COUNT = 5;
+const DUPLICATE_GROUP_DISPLAY_COUNT = 4;
+const DUPLICATE_SEGMENT_DISPLAY_COUNT = 6;
 const ROLE_ORDER = ["system", "user", "assistant", "tool", "tools"];
 const ROLE_DESCRIPTIONS = {
   system: "instructions",
@@ -709,6 +898,8 @@ function formatContextSource(intelligence) {
   switch (intelligence.contextWindow.source) {
     case "request":
       return intelligence.contextWindow.label;
+    case "provider":
+      return intelligence.contextWindow.label;
     case "model-rule":
       return intelligence.contextWindow.label;
     case "unknown":
@@ -729,6 +920,7 @@ function ContextIntelligenceStrip({
   const usageWidth = intelligence.usagePercent === null ? 0 : Math.max(1, intelligence.usagePercent * 100);
   const outputReserveLabel = intelligence.outputReserveTokens === null ? "No output reserve" : `Output reserve ${formatTokens(intelligence.outputReserveTokens)}`;
   const largestRole = intelligence.largestRole;
+  const visibleDiagnostics = intelligence.duplicateGroups.length === 0 ? intelligence.diagnostics : intelligence.diagnostics.filter((diagnostic) => diagnostic.kind !== "duplicate");
   return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "space-y-2", children: [
     /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "grid gap-x-4 gap-y-2 border-y border-border/60 py-2 text-xs sm:grid-cols-4", children: [
       /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "min-w-0", children: [
@@ -810,7 +1002,7 @@ function ContextIntelligenceStrip({
         ] })
       ] })
     ] }),
-    intelligence.diagnostics.length > 0 && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "grid gap-1.5 sm:grid-cols-2", children: intelligence.diagnostics.map((diagnostic) => /* @__PURE__ */ jsxRuntimeExports.jsxs(
+    visibleDiagnostics.length > 0 && /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "grid gap-1.5 sm:grid-cols-2", children: visibleDiagnostics.map((diagnostic) => /* @__PURE__ */ jsxRuntimeExports.jsxs(
       "div",
       {
         className: cn("rounded border px-2 py-1.5 text-xs", diagnosticTone(diagnostic)),
@@ -823,6 +1015,98 @@ function ContextIntelligenceStrip({
     )) })
   ] });
 }
+function resolveDuplicateSegment(duplicateSegment, segments) {
+  return segments.find((segment) => segment.path === duplicateSegment.path) ?? null;
+}
+function DuplicateContentPanel({
+  groups,
+  segments,
+  onSegmentActivate
+}) {
+  if (groups.length === 0) return null;
+  const visibleGroups = groups.slice(0, DUPLICATE_GROUP_DISPLAY_COUNT);
+  const hiddenGroupCount = groups.length - visibleGroups.length;
+  const totalRepeatedTokens = groups.reduce((sum, group) => sum + group.repeatedTokens, 0);
+  return /* @__PURE__ */ jsxRuntimeExports.jsxs("section", { className: "space-y-2 rounded border border-border/70 bg-muted/15 p-2", children: [
+    /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "flex flex-wrap items-center justify-between gap-2", children: [
+      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "text-xs font-medium text-foreground", children: "Duplicate Content" }),
+      /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "font-mono text-[11px] text-muted-foreground", children: [
+        String(groups.length),
+        " group",
+        groups.length === 1 ? "" : "s",
+        " | ~",
+        formatTokens(totalRepeatedTokens),
+        " repeated"
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "space-y-2", children: visibleGroups.map((group, groupIndex) => {
+      const visibleSegments = group.segments.slice(0, DUPLICATE_SEGMENT_DISPLAY_COUNT);
+      const hiddenSegmentCount = group.segments.length - visibleSegments.length;
+      return /* @__PURE__ */ jsxRuntimeExports.jsxs(
+        "div",
+        {
+          className: "space-y-1.5 border-t border-border/50 pt-2 first:border-t-0 first:pt-0",
+          children: [
+            /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "flex min-w-0 items-center gap-2 text-xs", children: [
+              /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "w-5 shrink-0 text-right font-mono text-muted-foreground/70", children: String(groupIndex + 1) }),
+              /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "min-w-0 flex-1 truncate text-foreground", children: group.firstLabel }),
+              /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: "shrink-0 font-mono text-muted-foreground", children: [
+                "x",
+                String(group.count),
+                " | ~",
+                formatTokens(group.repeatedTokens),
+                " saved"
+              ] })
+            ] }),
+            group.preview.length > 0 && /* @__PURE__ */ jsxRuntimeExports.jsx("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", children: group.preview }),
+            /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "ml-7 flex flex-wrap gap-1", children: [
+              visibleSegments.map((duplicateSegment, segmentIndex) => {
+                const target = resolveDuplicateSegment(duplicateSegment, segments);
+                const activate = target === null || onSegmentActivate === void 0 ? void 0 : onSegmentActivate;
+                const label = `${duplicateSegment.label} ~${formatTokens(
+                  duplicateSegment.tokens
+                )}`;
+                if (activate === void 0 || target === null) {
+                  return /* @__PURE__ */ jsxRuntimeExports.jsx(
+                    "span",
+                    {
+                      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,
+                      children: /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "truncate", children: label })
+                    },
+                    `${duplicateSegment.path}-${segmentIndex}`
+                  );
+                }
+                return /* @__PURE__ */ jsxRuntimeExports.jsx(
+                  "button",
+                  {
+                    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",
+                    children: /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "truncate", children: label })
+                  },
+                  `${duplicateSegment.path}-${segmentIndex}`
+                );
+              }),
+              hiddenSegmentCount > 0 && /* @__PURE__ */ jsxRuntimeExports.jsxs("span", { className: "inline-flex h-6 items-center rounded border border-border/40 px-1.5 font-mono text-[11px] text-muted-foreground/70", children: [
+                "+",
+                String(hiddenSegmentCount)
+              ] })
+            ] })
+          ]
+        },
+        group.key
+      );
+    }) }),
+    hiddenGroupCount > 0 && /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "border-t border-border/50 pt-2 font-mono text-[11px] text-muted-foreground", children: [
+      "+",
+      String(hiddenGroupCount),
+      " more duplicate group",
+      hiddenGroupCount === 1 ? "" : "s"
+    ] })
+  ] });
+}
 function aggregateByRole(segments) {
   const result = [];
   for (const role of ROLE_ORDER) {
@@ -853,6 +1137,7 @@ function RequestAnatomy({
   onSegmentActivate,
   segments: providedSegments
 }) {
+  const { providers } = useProviders();
   const [viewMode, setViewMode] = reactExports.useState("role");
   const segments = reactExports.useMemo(() => providedSegments ?? null, [providedSegments]);
   const total = reactExports.useMemo(
@@ -872,9 +1157,10 @@ function RequestAnatomy({
       segments,
       inputTokens,
       parsed,
-      model
+      model,
+      providers
     }),
-    [inputTokens, model, parsed, segments]
+    [inputTokens, model, parsed, providers, segments]
   );
   const showDivergenceWarning = reactExports.useMemo(() => {
     if (segments === null) return false;
@@ -951,6 +1237,14 @@ function RequestAnatomy({
       "Estimate differs from provider-reported input."
     ] }),
     intelligence !== null && /* @__PURE__ */ jsxRuntimeExports.jsx(ContextIntelligenceStrip, { intelligence }),
+    intelligence !== null && /* @__PURE__ */ jsxRuntimeExports.jsx(
+      DuplicateContentPanel,
+      {
+        groups: intelligence.duplicateGroups,
+        segments,
+        onSegmentActivate
+      }
+    ),
     /* @__PURE__ */ jsxRuntimeExports.jsx(
       SegmentBar,
       {

package/.output/server/_ssr/{ResponseView-D8tGHCGY.mjs → ResponseView-CwXAWOoE.mjs}

@@ -1,6 +1,6 @@
 import { r as reactExports, j as jsxRuntimeExports } from "../_libs/react.mjs";
-import { g as getLogFormatAdapter, f as formatTokens, c as cn, p as getStatusCategory, B as Badge, C as Collapsible, q as CollapsibleTrigger, s as CollapsibleContent, S as ScrollArea, t as JsonViewer, v as safeJsonValue } from "./ProxyViewerContainer-DiZjOTQT.mjs";
-import "./router-Bf0m6F0G.mjs";
+import { g as getLogFormatAdapter, f as formatTokens, c as cn, s as getStatusCategory, B as Badge, C as Collapsible, t as CollapsibleTrigger, v as CollapsibleContent, S as ScrollArea, w as JsonViewer, x as safeJsonValue } from "./ProxyViewerContainer-DrSMa5O7.mjs";
+import "./router-CSRaa_tu.mjs";
 import "../_libs/modelcontextprotocol__server.mjs";
 import "../_libs/jszip.mjs";
 import { Z as Zap, j as TriangleAlert, ab as CircleStop, B as Brain, b as ChevronDown, f as ChevronRight, T as Terminal } from "../_libs/lucide-react.mjs";

package/.output/server/_ssr/{StreamingChunkSequence-DGQnb1QE.mjs → StreamingChunkSequence-DRSR2FfN.mjs}

@@ -1,6 +1,6 @@
 import { r as reactExports, j as jsxRuntimeExports } from "../_libs/react.mjs";
-import { k as TooltipProvider, l as Tooltip, m as TooltipTrigger, B as Badge, n as TooltipContent, t as JsonViewer } from "./ProxyViewerContainer-DiZjOTQT.mjs";
-import "./router-Bf0m6F0G.mjs";
+import { k as TooltipProvider, l as Tooltip, m as TooltipTrigger, B as Badge, n as TooltipContent, w as JsonViewer } from "./ProxyViewerContainer-DrSMa5O7.mjs";
+import "./router-CSRaa_tu.mjs";
 import "../_libs/modelcontextprotocol__server.mjs";
 import "../_libs/jszip.mjs";
 import { b as ChevronDown, f as ChevronRight, L as LoaderCircle } from "../_libs/lucide-react.mjs";

package/.output/server/_ssr/{index-N25hqa7t.mjs → index-D4zn5CAg.mjs}

@@ -1,6 +1,6 @@
-import { P as ProxyViewerContainer } from "./ProxyViewerContainer-DiZjOTQT.mjs";
+import { P as ProxyViewerContainer } from "./ProxyViewerContainer-DrSMa5O7.mjs";
 import "../_libs/react.mjs";
-import "./router-Bf0m6F0G.mjs";
+import "./router-CSRaa_tu.mjs";
 import "../_libs/modelcontextprotocol__server.mjs";
 import "../_libs/jszip.mjs";
 import "../_libs/swr.mjs";

package/.output/server/_ssr/index.mjs

@@ -198,7 +198,7 @@ function getResponse() {
   return event.res;
 }
 async function getStartManifest(matchedRoutes) {
-  const { tsrStartManifest } = await import("../_tanstack-start-manifest_v-DlAyJ5DB.mjs");
+  const { tsrStartManifest } = await import("../_tanstack-start-manifest_v-CfvVUYYj.mjs");
   const startManifest = tsrStartManifest();
   const rootRoute = startManifest.routes[rootRouteId] = startManifest.routes[rootRouteId] || {};
   rootRoute.assets = rootRoute.assets || [];
@@ -767,7 +767,7 @@ let entriesPromise;
 let baseManifestPromise;
 let cachedFinalManifestPromise;
 async function loadEntries() {
-  const routerEntry = await import("./router-Bf0m6F0G.mjs").then((n) => n.i);
+  const routerEntry = await import("./router-CSRaa_tu.mjs").then((n) => n.m);
   const startEntry = await import("./start-HYkvq4Ni.mjs");
   return { startEntry, routerEntry };
 }