@tonyclaw/agent-inspector 4.0.1 → 4.0.3

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

@@ -1,737 +0,0 @@
-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" | "provider" | "model-rule" | "unknown";
-
-export type ContextHealthLevel = "ok" | "optimizable" | "risk";
-
-export type ContextWindow = {
-  tokens: number | null;
-  label: string;
-  source: ContextWindowSource;
-};
-
-export type RoleUsage = {
-  role: AnatomyRole;
-  label: string;
-  tokens: number;
-  percent: number;
-};
-
-export type ContextDiagnostic = {
-  kind: "duplicate" | "history-bloat" | "tool-schema" | "system-heavy";
-  severity: "watch" | "danger";
-  title: string;
-  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;
-  estimatedInputTokens: number;
-  outputReserveTokens: number | null;
-  windowUsedTokens: number | null;
-  remainingInputTokens: number | null;
-  remainingAfterReserveTokens: number | null;
-  usagePercent: number | null;
-  riskLevel: ContextRiskLevel;
-  roleUsages: RoleUsage[];
-  largestRole: RoleUsage | null;
-  diagnostics: ContextDiagnostic[];
-  duplicateGroups: DuplicateContextGroup[];
-  health: ContextHealth;
-};
-
-type MatchMode = "prefix" | "includes";
-
-type ModelContextRule = {
-  family: string;
-  tokens: number;
-  mode: MatchMode;
-  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",
-  "contextWindow",
-  "context_length",
-  "contextLength",
-  "max_context_length",
-  "maxContextLength",
-  "max_input_tokens",
-  "maxInputTokens",
-] as const;
-
-const OUTPUT_RESERVE_FIELDS = [
-  "max_tokens",
-  "maxTokens",
-  "max_completion_tokens",
-  "maxCompletionTokens",
-  "max_output_tokens",
-  "maxOutputTokens",
-] as const;
-
-const MODEL_CONTEXT_RULES: readonly ModelContextRule[] = [
-  {
-    family: "OpenAI GPT-4.1",
-    tokens: 1_047_576,
-    mode: "prefix",
-    patterns: ["gpt-4.1"],
-  },
-  {
-    family: "OpenAI GPT-4o",
-    tokens: 128_000,
-    mode: "prefix",
-    patterns: ["gpt-4o"],
-  },
-  {
-    family: "OpenAI o-series",
-    tokens: 128_000,
-    mode: "prefix",
-    patterns: ["o1", "o3", "o4"],
-  },
-  {
-    family: "Anthropic Claude",
-    tokens: 200_000,
-    mode: "prefix",
-    patterns: ["claude-"],
-  },
-  {
-    family: "DeepSeek V4",
-    tokens: 1_048_576,
-    mode: "prefix",
-    patterns: ["deepseek-v4-pro", "deepseek-v4-flash"],
-  },
-  {
-    family: "DeepSeek",
-    tokens: 64_000,
-    mode: "prefix",
-    patterns: ["deepseek-"],
-  },
-  {
-    family: "MiniMax M3",
-    tokens: 1_048_576,
-    mode: "includes",
-    patterns: ["minimax-m3"],
-  },
-  {
-    family: "MiniMax M2.7",
-    tokens: 204_800,
-    mode: "includes",
-    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"],
-  },
-];
-
-const ROLE_LABELS: Record<AnatomyRole, string> = {
-  system: "System",
-  user: "User messages",
-  assistant: "Assistant messages",
-  tool: "Tool results",
-  tools: "Tool definitions",
-};
-
-function readPositiveInteger(value: unknown): number | null {
-  if (typeof value === "number") {
-    if (Number.isFinite(value) && value > 0) return Math.floor(value);
-    return null;
-  }
-
-  if (typeof value === "string") {
-    const parsed = Number(value);
-    if (Number.isFinite(parsed) && parsed > 0) return Math.floor(parsed);
-  }
-
-  return null;
-}
-
-function readPositiveIntegerField(parsed: unknown, fields: readonly string[]): number | null {
-  for (const field of fields) {
-    const value = readPositiveInteger(safeGetOwnProperty(parsed, field));
-    if (value !== null) return value;
-  }
-  return null;
-}
-
-export function readRequestModel(parsed: unknown): string | null {
-  const value = safeGetOwnProperty(parsed, "model");
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  return trimmed === "" ? null : trimmed;
-}
-
-function matchesRule(model: string, rule: ModelContextRule): boolean {
-  switch (rule.mode) {
-    case "prefix":
-      return rule.patterns.some((pattern) => model.startsWith(pattern));
-    case "includes":
-      return rule.patterns.some((pattern) => model.includes(pattern));
-  }
-}
-
-export function resolveContextWindow(
-  model: string | null,
-  parsed: unknown,
-  providers: readonly ProviderConfig[] = [],
-): ContextWindow {
-  const explicitWindow = readPositiveIntegerField(parsed, EXPLICIT_CONTEXT_WINDOW_FIELDS);
-  if (explicitWindow !== null) {
-    return {
-      tokens: explicitWindow,
-      label: "Request metadata",
-      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,
-      label: "Unknown model",
-      source: "unknown",
-    };
-  }
-
-  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} local rule`,
-        source: "model-rule",
-      };
-    }
-  }
-
-  return {
-    tokens: null,
-    label: "No local rule",
-    source: "unknown",
-  };
-}
-
-function clampPercent(value: number): number {
-  if (value < 0) return 0;
-  if (value > 1) return 1;
-  return value;
-}
-
-function riskLevel(usagePercent: number | null): ContextRiskLevel {
-  if (usagePercent === null) return "unknown";
-  if (usagePercent >= DANGER_USAGE_PERCENT) return "danger";
-  if (usagePercent >= WATCH_USAGE_PERCENT) return "watch";
-  return "ok";
-}
-
-function sumSegments(segments: readonly AnatomySegment[], role: AnatomyRole): number {
-  return segments
-    .filter((segment) => segment.role === role)
-    .reduce((sum, segment) => sum + segment.size, 0);
-}
-
-function buildRoleUsages(segments: readonly AnatomySegment[], total: number): RoleUsage[] {
-  const roles: AnatomyRole[] = ["system", "user", "assistant", "tool", "tools"];
-  return roles
-    .map((role) => {
-      const tokens = sumSegments(segments, role);
-      return {
-        role,
-        label: ROLE_LABELS[role],
-        tokens,
-        percent: total > 0 ? tokens / total : 0,
-      };
-    })
-    .filter((usage) => usage.tokens > 0)
-    .sort((a, b) => b.tokens - a.tokens);
-}
-
-function normalizeDuplicateText(text: string): string {
-  return text.replace(/\s+/g, " ").trim().toLowerCase();
-}
-
-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 = {
-    tokens: number;
-    candidates: DuplicateCandidate[];
-  };
-
-  const buckets = new Map<string, DuplicateBucket>();
-  for (const segment of segments) {
-    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, {
-        tokens: existing.tokens + candidate.tokens,
-        candidates: [...existing.candidates, candidate],
-      });
-    }
-  }
-
-  const groups: DuplicateContextGroup[] = [];
-  for (const bucket of buckets.values()) {
-    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),
-    });
-  }
-
-  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",
-    severity: repeatedTokens >= LONG_TOOL_SCHEMA_TOKENS ? "danger" : "watch",
-    title: "Duplicate context",
-    detail: `${String(repeatedSegments)} repeated blocks across ${String(
-      repeatedGroups,
-    )} group${repeatedGroups === 1 ? "" : "s"}, ~${String(repeatedTokens)} repeated tokens.`,
-  };
-}
-
-function duplicateReclaimableTokens(duplicateGroups: readonly DuplicateContextGroup[]): number {
-  return duplicateGroups.reduce((sum, group) => sum + group.repeatedTokens, 0);
-}
-
-function diagnosticsForRolePressure(
-  roleUsages: readonly RoleUsage[],
-  total: number,
-  messageSegmentCount: number,
-): ContextDiagnostic[] {
-  const diagnostics: ContextDiagnostic[] = [];
-  const toolUsage = roleUsages.find((usage) => usage.role === "tools") ?? null;
-  if (
-    toolUsage !== null &&
-    (toolUsage.tokens >= LONG_TOOL_SCHEMA_TOKENS ||
-      (toolUsage.percent >= LARGE_ROLE_PERCENT && toolUsage.tokens >= SYSTEM_HEAVY_TOKENS))
-  ) {
-    diagnostics.push({
-      kind: "tool-schema",
-      severity: toolUsage.tokens >= LONG_TOOL_SCHEMA_TOKENS ? "danger" : "watch",
-      title: "Large tool schema",
-      detail: `Tool definitions take ${Math.round(toolUsage.percent * 100)}% of request context.`,
-    });
-  }
-
-  const systemUsage = roleUsages.find((usage) => usage.role === "system") ?? null;
-  if (
-    systemUsage !== null &&
-    systemUsage.tokens >= SYSTEM_HEAVY_TOKENS &&
-    systemUsage.percent >= SYSTEM_HEAVY_PERCENT
-  ) {
-    diagnostics.push({
-      kind: "system-heavy",
-      severity: "watch",
-      title: "Large system prompt",
-      detail: `System instructions take ${Math.round(systemUsage.percent * 100)}% of request context.`,
-    });
-  }
-
-  const historyTokens = roleUsages
-    .filter((usage) => usage.role === "user" || usage.role === "assistant" || usage.role === "tool")
-    .reduce((sum, usage) => sum + usage.tokens, 0);
-  const historyPercent = total > 0 ? historyTokens / total : 0;
-  if (
-    messageSegmentCount >= HISTORY_BLOAT_SEGMENTS &&
-    (historyTokens >= HISTORY_BLOAT_TOKENS || historyPercent >= HISTORY_BLOAT_PERCENT)
-  ) {
-    diagnostics.push({
-      kind: "history-bloat",
-      severity: historyPercent >= 0.85 ? "danger" : "watch",
-      title: "Conversation history growth",
-      detail: `${String(messageSegmentCount)} message blocks take ${Math.round(
-        historyPercent * 100,
-      )}% of request context.`,
-    });
-  }
-
-  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, providers);
-  const reservedTokens = outputReserveTokens ?? 0;
-  const windowUsedTokens =
-    contextWindow.tokens === null ? null : estimatedInputTokens + reservedTokens;
-  const remainingInputTokens =
-    contextWindow.tokens === null ? null : contextWindow.tokens - estimatedInputTokens;
-  const remainingAfterReserveTokens =
-    contextWindow.tokens === null
-      ? null
-      : contextWindow.tokens - estimatedInputTokens - reservedTokens;
-  const usagePercent =
-    contextWindow.tokens === null || windowUsedTokens === null
-      ? null
-      : clampPercent(windowUsedTokens / contextWindow.tokens);
-  const roleUsages = buildRoleUsages(segments, totalEstimatedTokens);
-  const largestRole = roleUsages[0] ?? null;
-  const messageSegmentCount = segments.filter((segment) => segment.role !== "tools").length;
-  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,
-    contextWindow,
-    estimatedInputTokens,
-    outputReserveTokens,
-    windowUsedTokens,
-    remainingInputTokens,
-    remainingAfterReserveTokens,
-    usagePercent,
-    riskLevel: risk,
-    roleUsages,
-    largestRole,
-    diagnostics,
-    duplicateGroups,
-    health: contextHealth({
-      risk,
-      contextWindow,
-      diagnostics,
-      duplicateGroups,
-    }),
-  };
-}
-
-export const CONTEXT_USAGE_THRESHOLDS = {
-  watch: WATCH_USAGE_PERCENT,
-  danger: DANGER_USAGE_PERCENT,
-} as const;