@tonyclaw/agent-inspector 2.0.9 → 2.0.11

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

@@ -1,9 +1,14 @@
-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 ContextHealthLevel = "ok" | "optimizable" | "risk";
 
 export type ContextWindow = {
   tokens: number | null;
@@ -25,6 +30,30 @@ 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 ContextHealth = {
+  level: ContextHealthLevel;
+  opportunityCount: number;
+  reclaimableTokens: number;
+};
+
 export type ContextIntelligence = {
   model: string | null;
   contextWindow: ContextWindow;
@@ -38,6 +67,8 @@ export type ContextIntelligence = {
   roleUsages: RoleUsage[];
   largestRole: RoleUsage | null;
   diagnostics: ContextDiagnostic[];
+  duplicateGroups: DuplicateContextGroup[];
+  health: ContextHealth;
 };
 
 type MatchMode = "prefix" | "includes";
@@ -49,17 +80,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 +165,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 +178,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 +237,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 +251,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 +268,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 +325,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",
@@ -297,6 +560,10 @@ function duplicateDiagnostic(segments: readonly AnatomySegment[]): ContextDiagno
   };
 }
 
+function duplicateReclaimableTokens(duplicateGroups: readonly DuplicateContextGroup[]): number {
+  return duplicateGroups.reduce((sum, group) => sum + group.repeatedTokens, 0);
+}
+
 function diagnosticsForRolePressure(
   roleUsages: readonly RoleUsage[],
   total: number,
@@ -352,22 +619,51 @@ 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,
   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,13 +680,15 @@ 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,
     messageSegmentCount,
   );
   if (duplicate !== null) diagnostics.unshift(duplicate);
+  const risk = riskLevel(usagePercent);
 
   return {
     model: requestModel,
@@ -401,10 +699,17 @@ export function analyzeContextIntelligence({
     remainingInputTokens,
     remainingAfterReserveTokens,
     usagePercent,
-    riskLevel: riskLevel(usagePercent),
+    riskLevel: risk,
     roleUsages,
     largestRole,
     diagnostics,
+    duplicateGroups,
+    health: contextHealth({
+      risk,
+      contextWindow,
+      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>;