@tonyclaw/agent-inspector 2.0.43 → 2.1.1

package/src/components/ui/json-viewer.tsx

@@ -438,6 +438,12 @@ export function JsonViewer({
             <CopyValueButton value={data} />
           </div>
         )}
+        {entries.length === 0 && (
+          <div className="rounded-md border border-white/10 bg-black/20 px-3 py-2 text-muted-foreground">
+            <span className="text-cyan-300">{isArray ? "[]" : "{}"}</span>
+            <span className="ml-2 text-[10px] uppercase">0 items</span>
+          </div>
+        )}
         <div key={bulkRevision}>
           {entries.map(([key, childValue]) => (
             <JsonNode

package/src/proxy/logIndex.ts

@@ -4,12 +4,56 @@ import { join, dirname } from "node:path";
 import { createInterface } from "node:readline";
 import { Buffer } from "node:buffer";
 import { resolveLogDir, logger } from "./logger";
+import type { ApiFormat, CapturedLog } from "./schemas";
+
+export type LogIndexSummary = {
+  id: number;
+  timestamp: string;
+  method: string;
+  path: string;
+  model: string | null;
+  sessionId: string | null;
+  responseStatus: number | null;
+  inputTokens: number | null;
+  outputTokens: number | null;
+  cacheCreationInputTokens: number | null;
+  cacheReadInputTokens: number | null;
+  elapsedMs: number | null;
+  firstChunkMs: number | null;
+  totalStreamMs: number | null;
+  tokensPerSecond: number | null;
+  streaming: boolean;
+  userAgent: string | null;
+  origin: string | null;
+  apiFormat: ApiFormat;
+  isTest: boolean;
+  replayOfLogId: number | null;
+  providerName: string | null;
+  clientPort: number | null;
+  clientPid: number | null;
+  clientCwd: string | null;
+  clientProjectFolder: string | null;
+  streamingChunksPath: string | null;
+  rawRequestBodyBytes: number | null;
+  responseTextBytes: number | null;
+  warnings?: string[];
+  error: string | null;
+};
 
 export type LogIndexEntry = {
   id: number;
   file: string;
   byteOffset: number;
   byteLength: number;
+  sessionId?: string | null;
+  model?: string | null;
+  summary?: LogIndexSummary;
+};
+
+export type LogIndexEntryMetadata = {
+  sessionId: string | null;
+  model: string | null;
+  summary: LogIndexSummary;
 };
 
 type LogIndex = {
@@ -29,6 +73,50 @@ function getIndexPath(): string {
 
 let cachedIndex: LogIndex | null = null;
 
+function textByteLength(value: string | null): number | null {
+  return value === null ? null : Buffer.byteLength(value, "utf8");
+}
+
+export function createLogIndexEntryMetadata(log: CapturedLog): LogIndexEntryMetadata {
+  return {
+    sessionId: log.sessionId,
+    model: log.model,
+    summary: {
+      id: log.id,
+      timestamp: log.timestamp,
+      method: log.method,
+      path: log.path,
+      model: log.model,
+      sessionId: log.sessionId,
+      responseStatus: log.responseStatus,
+      inputTokens: log.inputTokens,
+      outputTokens: log.outputTokens,
+      cacheCreationInputTokens: log.cacheCreationInputTokens,
+      cacheReadInputTokens: log.cacheReadInputTokens,
+      elapsedMs: log.elapsedMs,
+      firstChunkMs: log.firstChunkMs ?? null,
+      totalStreamMs: log.totalStreamMs ?? null,
+      tokensPerSecond: log.tokensPerSecond ?? null,
+      streaming: log.streaming,
+      userAgent: log.userAgent,
+      origin: log.origin,
+      apiFormat: log.apiFormat,
+      isTest: log.isTest ?? false,
+      replayOfLogId: log.replayOfLogId ?? null,
+      providerName: log.providerName ?? null,
+      clientPort: log.clientPort ?? null,
+      clientPid: log.clientPid ?? null,
+      clientCwd: log.clientCwd ?? null,
+      clientProjectFolder: log.clientProjectFolder ?? null,
+      streamingChunksPath: log.streamingChunksPath ?? null,
+      rawRequestBodyBytes: log.rawRequestBodyBytes ?? textByteLength(log.rawRequestBody),
+      responseTextBytes: log.responseTextBytes ?? textByteLength(log.responseText),
+      warnings: log.warnings,
+      error: log.error ?? null,
+    },
+  };
+}
+
 function createEmptyIndex(): LogIndex {
   return {
     version: INDEX_VERSION,
@@ -100,9 +188,13 @@ export async function addToIndex(
   file: string,
   byteOffset: number,
   byteLength: number,
+  metadata?: LogIndexEntryMetadata,
 ): Promise<void> {
   const index = await loadIndex();
-  index.entries[id] = { id, file, byteOffset, byteLength };
+  index.entries[id] =
+    metadata === undefined
+      ? { id, file, byteOffset, byteLength }
+      : { id, file, byteOffset, byteLength, ...metadata };
   if (id > index.maxId) {
     index.maxId = id;
   }
@@ -154,6 +246,98 @@ type FileIndexResult = {
   maxId: number;
 };
 
+function readStringOrNullField(entry: object, field: string): string | null {
+  const desc = Object.getOwnPropertyDescriptor(entry, field);
+  if (desc === undefined) return null;
+  if (typeof desc.value === "string") return desc.value;
+  return null;
+}
+
+function readStringField(entry: object, field: string): string {
+  return readStringOrNullField(entry, field) ?? "";
+}
+
+function readNumberOrNullField(entry: object, field: string): number | null {
+  const desc = Object.getOwnPropertyDescriptor(entry, field);
+  if (desc === undefined) return null;
+  return typeof desc.value === "number" ? desc.value : null;
+}
+
+function readBooleanField(entry: object, field: string): boolean {
+  const desc = Object.getOwnPropertyDescriptor(entry, field);
+  if (desc === undefined) return false;
+  return typeof desc.value === "boolean" ? desc.value : false;
+}
+
+function readApiFormatField(entry: object): ApiFormat {
+  const value = readStringOrNullField(entry, "apiFormat");
+  switch (value) {
+    case "anthropic":
+      return "anthropic";
+    case "openai":
+      return "openai";
+    case "unknown":
+    case null:
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+
+function readStringArrayField(entry: object, field: string): string[] | undefined {
+  const desc = Object.getOwnPropertyDescriptor(entry, field);
+  if (desc === undefined || !Array.isArray(desc.value)) return undefined;
+
+  const values: string[] = [];
+  for (const item of desc.value) {
+    if (typeof item !== "string") return undefined;
+    values.push(item);
+  }
+  return values;
+}
+
+function readTextByteLength(entry: object, bytesField: string, textField: string): number | null {
+  const explicitBytes = readNumberOrNullField(entry, bytesField);
+  if (explicitBytes !== null && explicitBytes >= 0) return explicitBytes;
+  return textByteLength(readStringOrNullField(entry, textField));
+}
+
+function readLogIndexSummary(entry: object, id: number): LogIndexSummary {
+  return {
+    id,
+    timestamp: readStringField(entry, "timestamp"),
+    method: readStringField(entry, "method"),
+    path: readStringField(entry, "path"),
+    model: readStringOrNullField(entry, "model"),
+    sessionId: readStringOrNullField(entry, "sessionId"),
+    responseStatus: readNumberOrNullField(entry, "responseStatus"),
+    inputTokens: readNumberOrNullField(entry, "inputTokens"),
+    outputTokens: readNumberOrNullField(entry, "outputTokens"),
+    cacheCreationInputTokens: readNumberOrNullField(entry, "cacheCreationInputTokens"),
+    cacheReadInputTokens: readNumberOrNullField(entry, "cacheReadInputTokens"),
+    elapsedMs: readNumberOrNullField(entry, "elapsedMs"),
+    firstChunkMs: readNumberOrNullField(entry, "firstChunkMs"),
+    totalStreamMs: readNumberOrNullField(entry, "totalStreamMs"),
+    tokensPerSecond: readNumberOrNullField(entry, "tokensPerSecond"),
+    streaming: readBooleanField(entry, "streaming"),
+    userAgent: readStringOrNullField(entry, "userAgent"),
+    origin: readStringOrNullField(entry, "origin"),
+    apiFormat: readApiFormatField(entry),
+    isTest: readBooleanField(entry, "isTest"),
+    replayOfLogId: readNumberOrNullField(entry, "replayOfLogId"),
+    providerName: readStringOrNullField(entry, "providerName"),
+    clientPort: readNumberOrNullField(entry, "clientPort"),
+    clientPid: readNumberOrNullField(entry, "clientPid"),
+    clientCwd: readStringOrNullField(entry, "clientCwd"),
+    clientProjectFolder: readStringOrNullField(entry, "clientProjectFolder"),
+    streamingChunksPath: readStringOrNullField(entry, "streamingChunksPath"),
+    rawRequestBodyBytes: readTextByteLength(entry, "rawRequestBodyBytes", "rawRequestBody"),
+    responseTextBytes: readTextByteLength(entry, "responseTextBytes", "responseText"),
+    warnings: readStringArrayField(entry, "warnings"),
+    error: readStringOrNullField(entry, "error"),
+  };
+}
+
 async function indexFile(filePath: string, file: string): Promise<FileIndexResult> {
   const entries: Record<number, LogIndexEntry> = {};
   let maxId = 0;
@@ -179,6 +363,9 @@ async function indexFile(filePath: string, file: string): Promise<FileIndexResul
               file,
               byteOffset,
               byteLength: lineBytes,
+              sessionId: readStringOrNullField(entry, "sessionId"),
+              model: readStringOrNullField(entry, "model"),
+              summary: readLogIndexSummary(entry, entryId),
             };
           }
         }