@tonyclaw/agent-inspector 2.0.8 → 2.0.10

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

@@ -1,11 +1,14 @@
 import { Info } from "lucide-react";
 import { type JSX, useMemo, useState } from "react";
 import { cn, formatTokens } from "../../../lib/utils";
+import { useProviders } from "../../../lib/useProviders";
 import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from "../../ui/tooltip";
 import {
   analyzeContextIntelligence,
   CONTEXT_USAGE_THRESHOLDS,
   type ContextDiagnostic,
+  type DuplicateContextGroup,
+  type DuplicateContextSegment,
   type ContextIntelligence,
   type ContextRiskLevel,
 } from "./contextIntelligence";
@@ -29,6 +32,8 @@ type ContextViewMode = "role" | "segment";
 
 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: AnatomyRole[] = ["system", "user", "assistant", "tool", "tools"];
 
 const ROLE_DESCRIPTIONS: Record<AnatomyRole, string> = {
@@ -85,6 +90,8 @@ function formatContextSource(intelligence: ContextIntelligence): string {
   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":
@@ -115,6 +122,10 @@ function ContextIntelligenceStrip({
       ? "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 (
     <div className="space-y-2">
@@ -199,9 +210,9 @@ function ContextIntelligenceStrip({
         </div>
       )}
 
-      {intelligence.diagnostics.length > 0 && (
+      {visibleDiagnostics.length > 0 && (
         <div className="grid gap-1.5 sm:grid-cols-2">
-          {intelligence.diagnostics.map((diagnostic) => (
+          {visibleDiagnostics.map((diagnostic) => (
             <div
               key={`${diagnostic.kind}-${diagnostic.title}`}
               className={cn("rounded border px-2 py-1.5 text-xs", diagnosticTone(diagnostic))}
@@ -216,6 +227,116 @@ function ContextIntelligenceStrip({
   );
 }
 
+function resolveDuplicateSegment(
+  duplicateSegment: DuplicateContextSegment,
+  segments: readonly AnatomySegment[],
+): AnatomySegment | null {
+  return segments.find((segment) => segment.path === duplicateSegment.path) ?? null;
+}
+
+function DuplicateContentPanel({
+  groups,
+  segments,
+  onSegmentActivate,
+}: {
+  groups: readonly DuplicateContextGroup[];
+  segments: readonly AnatomySegment[];
+  onSegmentActivate?: (segment: AnatomySegment) => void;
+}): JSX.Element | null {
+  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 (
+    <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">
+          {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>
+
+              {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>
+                      </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>
+
+      {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>
+  );
+}
+
 function aggregateByRole(segments: AnatomySegment[]): AnatomySegment[] {
   const result: AnatomySegment[] = [];
   for (const role of ROLE_ORDER) {
@@ -254,6 +375,7 @@ export function RequestAnatomy({
   onSegmentActivate,
   segments: providedSegments,
 }: RequestAnatomyProps): JSX.Element | null {
+  const { providers } = useProviders();
   const [viewMode, setViewMode] = useState<ContextViewMode>("role");
   const segments = useMemo(() => providedSegments ?? null, [providedSegments]);
   const total = useMemo(
@@ -277,8 +399,9 @@ export function RequestAnatomy({
             inputTokens,
             parsed,
             model,
+            providers,
           }),
-    [inputTokens, model, parsed, segments],
+    [inputTokens, model, parsed, providers, segments],
   );
 
   const showDivergenceWarning = useMemo(() => {
@@ -368,6 +491,14 @@ export function RequestAnatomy({
 
         {intelligence !== null && <ContextIntelligenceStrip intelligence={intelligence} />}
 
+        {intelligence !== null && (
+          <DuplicateContentPanel
+            groups={intelligence.duplicateGroups}
+            segments={segments}
+            onSegmentActivate={onSegmentActivate}
+          />
+        )}
+
         <SegmentBar
           segments={displayedSegments}
           totalTokens={displayedTotal}

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

@@ -1,9 +1,12 @@
-import { safeGetOwnProperty } from "../../../lib/objectUtils";
+import { isPlainRecord, safeGetOwnProperty } from "../../../lib/objectUtils";
+import type { ProviderConfig } from "../../../lib/providerContract";
+import { resolveProviderContextWindow } from "../../../lib/providerModelMetadata";
+import { countCharacters, estimateTokens } from "./tokenEstimate";
 import type { AnatomyRole, AnatomySegment } from "./types";
 
 export type ContextRiskLevel = "unknown" | "ok" | "watch" | "danger";
 
-export type ContextWindowSource = "request" | "model-rule" | "unknown";
+export type ContextWindowSource = "request" | "provider" | "model-rule" | "unknown";
 
 export type ContextWindow = {
   tokens: number | null;
@@ -25,6 +28,24 @@ export type ContextDiagnostic = {
   detail: string;
 };
 
+export type DuplicateContextSegment = {
+  role: AnatomyRole;
+  label: string;
+  path: string;
+  tokens: number;
+  characters: number;
+};
+
+export type DuplicateContextGroup = {
+  key: string;
+  count: number;
+  totalTokens: number;
+  repeatedTokens: number;
+  preview: string;
+  firstLabel: string;
+  segments: DuplicateContextSegment[];
+};
+
 export type ContextIntelligence = {
   model: string | null;
   contextWindow: ContextWindow;
@@ -38,6 +59,7 @@ export type ContextIntelligence = {
   roleUsages: RoleUsage[];
   largestRole: RoleUsage | null;
   diagnostics: ContextDiagnostic[];
+  duplicateGroups: DuplicateContextGroup[];
 };
 
 type MatchMode = "prefix" | "includes";
@@ -49,17 +71,45 @@ type ModelContextRule = {
   patterns: readonly string[];
 };
 
+type DuplicateCandidate = {
+  role: AnatomyRole;
+  label: string;
+  path: string;
+  tokens: number;
+  characters: number;
+  text: string;
+};
+
 const WATCH_USAGE_PERCENT = 0.75;
 const DANGER_USAGE_PERCENT = 0.9;
 const LONG_TOOL_SCHEMA_TOKENS = 8_000;
 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 = 60_000;
 const HISTORY_BLOAT_PERCENT = 0.7;
 const SYSTEM_HEAVY_TOKENS = 3_000;
 const SYSTEM_HEAVY_PERCENT = 0.3;
+const DUPLICATE_PREVIEW_CHARS = 160;
+const DUPLICATE_NESTED_FIELD_NAMES = new Set([
+  "answer",
+  "body",
+  "content",
+  "data",
+  "error",
+  "message",
+  "markdown",
+  "output",
+  "response",
+  "result",
+  "stderr",
+  "stdout",
+  "text",
+  "transcript",
+]);
 
 const EXPLICIT_CONTEXT_WINDOW_FIELDS = [
   "context_window",
@@ -106,6 +156,12 @@ const MODEL_CONTEXT_RULES: readonly ModelContextRule[] = [
     mode: "prefix",
     patterns: ["claude-"],
   },
+  {
+    family: "DeepSeek V4",
+    tokens: 1_000_000,
+    mode: "prefix",
+    patterns: ["deepseek-v4-pro", "deepseek-v4-flash"],
+  },
   {
     family: "DeepSeek",
     tokens: 64_000,
@@ -113,10 +169,16 @@ const MODEL_CONTEXT_RULES: readonly ModelContextRule[] = [
     patterns: ["deepseek-"],
   },
   {
-    family: "MiniMax",
+    family: "MiniMax M3",
     tokens: 1_000_000,
     mode: "includes",
-    patterns: ["minimax"],
+    patterns: ["minimax-m3"],
+  },
+  {
+    family: "MiniMax M2",
+    tokens: 204_800,
+    mode: "includes",
+    patterns: ["minimax-m2.7", "minimax-m2.5", "minimax-m2.1"],
   },
 ];
 
@@ -166,7 +228,11 @@ function matchesRule(model: string, rule: ModelContextRule): boolean {
   }
 }
 
-export function resolveContextWindow(model: string | null, parsed: unknown): ContextWindow {
+export function resolveContextWindow(
+  model: string | null,
+  parsed: unknown,
+  providers: readonly ProviderConfig[] = [],
+): ContextWindow {
   const explicitWindow = readPositiveIntegerField(parsed, EXPLICIT_CONTEXT_WINDOW_FIELDS);
   if (explicitWindow !== null) {
     return {
@@ -176,6 +242,15 @@ export function resolveContextWindow(model: string | null, parsed: unknown): Con
     };
   }
 
+  const providerWindow = resolveProviderContextWindow(model, providers);
+  if (providerWindow !== null) {
+    return {
+      tokens: providerWindow.tokens,
+      label: `${providerWindow.providerName} config`,
+      source: "provider",
+    };
+  }
+
   if (model === null) {
     return {
       tokens: null,
@@ -184,12 +259,12 @@ export function resolveContextWindow(model: string | null, parsed: unknown): Con
     };
   }
 
-  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",
       };
     }
@@ -241,51 +316,230 @@ function normalizeDuplicateText(text: string): string {
   return text.replace(/\s+/g, " ").trim().toLowerCase();
 }
 
-function duplicateDiagnostic(segments: readonly AnatomySegment[]): ContextDiagnostic | null {
+function duplicatePreview(text: string): string {
+  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: DuplicateCandidate): DuplicateContextSegment {
+  return {
+    role: candidate.role,
+    label: candidate.label,
+    path: candidate.path,
+    tokens: candidate.tokens,
+    characters: candidate.characters,
+  };
+}
+
+function duplicateCandidateFromSegment(segment: AnatomySegment): DuplicateCandidate {
+  return {
+    role: segment.role,
+    label: segment.label,
+    path: segment.path,
+    tokens: segment.size,
+    characters: segment.characters,
+    text: segment.text,
+  };
+}
+
+function jsonLikeText(text: string): boolean {
+  const trimmed = text.trim();
+  return trimmed.startsWith("{") || trimmed.startsWith("[");
+}
+
+function parseJsonLikeText(text: string): unknown | null {
+  if (!jsonLikeText(text)) return null;
+  try {
+    const parsed: unknown = JSON.parse(text);
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function normalizePathFieldName(field: string): string {
+  return field.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+
+function lastNamedPathField(path: readonly string[]): string | null {
+  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: readonly string[]): boolean {
+  const field = lastNamedPathField(path);
+  if (field === null) return false;
+  return DUPLICATE_NESTED_FIELD_NAMES.has(normalizePathFieldName(field));
+}
+
+function formatNestedDuplicatePath(path: readonly string[]): string {
+  return path
+    .map((part) => (part.startsWith("[") ? part : `.${part}`))
+    .join("")
+    .replace(/^\./, "");
+}
+
+function duplicateCandidateFromNestedText(
+  segment: AnatomySegment,
+  text: string,
+  path: readonly string[],
+): DuplicateCandidate | null {
+  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,
+}: {
+  value: unknown;
+  segment: AnatomySegment;
+  path: readonly string[];
+  depth: number;
+  candidates: DuplicateCandidate[];
+}): void {
+  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: AnatomySegment): DuplicateCandidate[] {
+  const segmentCandidate = duplicateCandidateFromSegment(segment);
+  const parsed = parseJsonLikeText(segment.text);
+  if (parsed === null) return [segmentCandidate];
+
+  const candidates: DuplicateCandidate[] = [];
+  collectNestedDuplicateCandidates({
+    value: parsed,
+    segment,
+    path: [],
+    depth: 0,
+    candidates,
+  });
+
+  const normalizedSegment = normalizeDuplicateText(segment.text);
+  const seen = 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: readonly AnatomySegment[]): DuplicateContextGroup[] {
   type DuplicateBucket = {
-    count: number;
     tokens: number;
-    firstTokens: number;
-    label: string;
+    candidates: DuplicateCandidate[];
   };
 
   const buckets = new Map<string, DuplicateBucket>();
   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 === undefined) {
+    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 === undefined) {
+        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: DuplicateBucket | null = null;
+  const groups: DuplicateContextGroup[] = [];
   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: readonly DuplicateContextGroup[],
+): ContextDiagnostic | null {
+  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",
@@ -357,17 +611,19 @@ export function analyzeContextIntelligence({
   inputTokens,
   parsed,
   model,
+  providers = [],
 }: {
   segments: readonly AnatomySegment[];
   inputTokens: number | null;
   parsed: unknown;
   model: string | null;
+  providers?: readonly ProviderConfig[];
 }): ContextIntelligence {
   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;
@@ -384,7 +640,8 @@ export 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,
@@ -405,6 +662,7 @@ export function analyzeContextIntelligence({
     roleUsages,
     largestRole,
     diagnostics,
+    duplicateGroups,
   };
 }
 

package/src/lib/providerContract.ts

@@ -1,5 +1,14 @@
 import { z } from "zod";
 
+export const ProviderModelMetadataSchema = z.object({
+  model: z.string().min(1),
+  contextWindow: z.number().int().positive().optional(),
+  outputLimit: z.number().int().positive().optional(),
+  source: z.enum(["manual", "registry"]).optional(),
+  sourceUrl: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+
 /**
  * Persisted provider shape shared by the server store and browser API clients.
  *
@@ -18,9 +27,12 @@ export const ProviderConfigSchema = z.object({
   openaiBaseUrl: z.string().optional(),
   authHeader: z.enum(["bearer", "x-api-key"]).optional().default("bearer"),
   apiDocsUrl: z.string().optional(),
+  modelMetadataUrl: z.string().optional(),
+  modelMetadata: z.array(ProviderModelMetadataSchema).optional(),
   source: z.enum(["company", "personal"]).optional(),
   createdAt: z.string(),
   updatedAt: z.string(),
 });
 
+export type ProviderModelMetadata = z.infer<typeof ProviderModelMetadataSchema>;
 export type ProviderConfig = z.infer<typeof ProviderConfigSchema>;