@tonyclaw/agent-inspector 2.0.23 → 2.0.25

package/src/proxy/logFinalizer.ts

@@ -1,4 +1,5 @@
-import { readFileSync, rmSync } from "node:fs";
+import { Buffer } from "node:buffer";
+import { readFileSync, rmSync, statSync } from "node:fs";
 import { Worker } from "node:worker_threads";
 import { writeChunks } from "./chunkStorage";
 import { formatForPath } from "./formats";
@@ -46,6 +47,16 @@ export type FinalizeLogResult = {
   cleanupRawStreamPath?: string | null;
 };
 
+const DEFAULT_MAX_FINALIZE_STREAM_BYTES = 20 * 1024 * 1024;
+
+function resolveMaxFinalizeStreamBytes(): number {
+  const raw = process.env["AGENT_INSPECTOR_MAX_FINALIZE_STREAM_BYTES"];
+  if (raw === undefined || raw === "") return DEFAULT_MAX_FINALIZE_STREAM_BYTES;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 1) return DEFAULT_MAX_FINALIZE_STREAM_BYTES;
+  return Math.floor(parsed);
+}
+
 export function buildFileLogEntry(log: CapturedLog, upstreamUrl: string): Record<string, unknown> {
   return {
     timestamp: log.timestamp,
@@ -148,6 +159,50 @@ function cleanupPathForRawStream(rawStream: string | RawStreamSource): string |
   }
 }
 
+type OversizedRawStream = {
+  byteLength: number;
+  limit: number;
+};
+
+function rawStreamByteLength(rawStream: string | RawStreamSource): number | null {
+  if (typeof rawStream === "string") {
+    return Buffer.byteLength(rawStream, "utf8");
+  }
+
+  switch (rawStream.type) {
+    case "memory":
+      return Buffer.byteLength(rawStream.rawStream, "utf8");
+    case "file":
+      try {
+        return statSync(rawStream.path).size;
+      } catch {
+        return null;
+      }
+  }
+}
+
+function getOversizedRawStream(rawStream: string | RawStreamSource): OversizedRawStream | null {
+  const limit = resolveMaxFinalizeStreamBytes();
+  const byteLength = rawStreamByteLength(rawStream);
+  if (byteLength === null || byteLength <= limit) return null;
+  return { byteLength, limit };
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes} bytes`;
+  if (bytes < 1024 * 1024) return `${Math.ceil(bytes / 1024)} KB`;
+  return `${Math.ceil(bytes / (1024 * 1024))} MB`;
+}
+
+function oversizedRawStreamText(oversized: OversizedRawStream): string {
+  return (
+    `Streaming response omitted because the captured raw stream is ${formatBytes(
+      oversized.byteLength,
+    )}, exceeding the finalize limit of ${formatBytes(oversized.limit)}. ` +
+    "Increase AGENT_INSPECTOR_MAX_FINALIZE_STREAM_BYTES if this response must be parsed."
+  );
+}
+
 function readRawStream(rawStream: string | RawStreamSource): {
   rawStreamText: string;
   cleanupRawStreamPath: string | null;
@@ -180,6 +235,19 @@ function finalizeStreaming(job: FinalizeStreamingLogJob, log: CapturedLog): Fina
     );
   }
 
+  const oversized = getOversizedRawStream(job.rawStream);
+  if (oversized !== null) {
+    log.elapsedMs = job.elapsedMs;
+    log.responseStatus = job.responseStatus;
+    log.responseText = oversizedRawStreamText(oversized);
+    return {
+      log,
+      upstreamUrl: job.upstreamUrl,
+      error: null,
+      cleanupRawStreamPath: cleanupPathForRawStream(job.rawStream),
+    };
+  }
+
   let rawStreamText = "";
   let cleanupRawStreamPath: string | null = null;
   try {
@@ -227,6 +295,16 @@ function finalizeStreamAbort(job: FinalizeStreamAbortLogJob, log: CapturedLog):
   try {
     log.elapsedMs = job.elapsedMs;
     if (job.hasChunks && formatHandler !== null) {
+      const oversized = getOversizedRawStream(job.rawStream);
+      if (oversized !== null) {
+        log.responseText = `Client aborted. ${oversizedRawStreamText(oversized)}`;
+        return {
+          log,
+          upstreamUrl: job.upstreamUrl,
+          error: "Client aborted",
+          cleanupRawStreamPath: cleanupPathForRawStream(job.rawStream),
+        };
+      }
       const raw = readRawStream(job.rawStream);
       rawStreamText = raw.rawStreamText;
       cleanupRawStreamPath = raw.cleanupRawStreamPath;

package/src/proxy/logIndex.ts

@@ -5,7 +5,7 @@ import { createInterface } from "node:readline";
 import { Buffer } from "node:buffer";
 import { resolveLogDir, logger } from "./logger";
 
-type LogIndexEntry = {
+export type LogIndexEntry = {
   id: number;
   file: string;
   byteOffset: number;
@@ -144,6 +144,11 @@ export async function findInIndex(id: number): Promise<LogIndexEntry | null> {
   return index.entries[id] ?? null;
 }
 
+export async function listIndexEntries(): Promise<LogIndexEntry[]> {
+  const index = await loadIndex();
+  return Object.values(index.entries).sort((left, right) => left.id - right.id);
+}
+
 type FileIndexResult = {
   entries: Record<number, LogIndexEntry>;
   maxId: number;

package/src/proxy/schemas.ts

@@ -56,6 +56,9 @@ export const CapturedLogSchema = z.object({
   clientProjectFolder: z.string().nullable().optional(),
   streamingChunks: StreamingChunksArraySchema.optional(),
   streamingChunksPath: z.string().nullable().optional(),
+  rawRequestBodyBytes: z.number().int().nonnegative().nullable().optional(),
+  responseTextBytes: z.number().int().nonnegative().nullable().optional(),
+  bodyContentMode: z.enum(["full", "compact", "truncated"]).optional(),
   /** Error message from streaming response (e.g., SSE error event) */
   error: z.string().nullable().optional(),
 });

package/src/proxy/store.ts

@@ -25,7 +25,9 @@ import {
   flushIndex,
   getNextLogId,
   getCurrentLogFile,
+  listIndexEntries,
   rebuildIndex,
+  type LogIndexEntry,
 } from "./logIndex";
 import { writeChunks } from "./chunkStorage";
 import type { CapturedLog } from "./schemas";
@@ -75,6 +77,7 @@ export type ListLogsPageOptions = {
   model?: string;
   offset: number;
   limit: number;
+  includeBodies?: boolean;
 };
 
 export type ListLogsPageResult = {
@@ -116,6 +119,29 @@ function removeFromCache(id: number): void {
   memoryCache.delete(id);
 }
 
+function textByteLength(value: string | null): number | null {
+  if (value === null) return null;
+  return Buffer.byteLength(value, "utf8");
+}
+
+export function compactLogForList(log: CapturedLog): CapturedLog {
+  return {
+    ...log,
+    rawRequestBody: null,
+    responseText: null,
+    rawHeaders: undefined,
+    headers: undefined,
+    streamingChunks: undefined,
+    rawRequestBodyBytes: textByteLength(log.rawRequestBody),
+    responseTextBytes: textByteLength(log.responseText),
+    bodyContentMode: "compact",
+  };
+}
+
+function prepareLogForList(log: CapturedLog, includeBodies: boolean): CapturedLog {
+  return includeBodies ? log : compactLogForList(log);
+}
+
 /**
  * Add a test log entry to the in-memory store and persistent log file.
  * This is used by the provider test endpoint to seed the provider-test session.
@@ -385,11 +411,62 @@ async function visitPersistedLogFile(
   }
 }
 
+function canUseIndexedListPage(options: ListLogsPageOptions): boolean {
+  return options.sessionId === undefined && options.model === undefined;
+}
+
+function hasUsableIndexOffset(entry: LogIndexEntry): boolean {
+  return entry.byteOffset >= 0 && entry.byteLength > 0;
+}
+
+async function listLogsPageFromIndex(
+  options: ListLogsPageOptions,
+  allowRebuild: boolean,
+): Promise<ListLogsPageResult | null> {
+  if (!canUseIndexedListPage(options)) return null;
+
+  let entries = await listIndexEntries();
+  if (entries.length === 0 && allowRebuild) {
+    await rebuildIndex();
+    entries = await listIndexEntries();
+  }
+
+  const pageStart = options.offset;
+  const pageEnd = options.offset + options.limit;
+  const pageEntries = entries.slice(pageStart, pageEnd);
+  const hasIncompleteOffset = pageEntries.some((entry) => !hasUsableIndexOffset(entry));
+
+  if (hasIncompleteOffset) {
+    if (!allowRebuild) return null;
+    await rebuildIndex();
+    return await listLogsPageFromIndex(options, false);
+  }
+
+  const logs: CapturedLog[] = [];
+  const includeBodies = options.includeBodies !== false;
+  for (const entry of pageEntries) {
+    const log = await getLogById(entry.id);
+    if (log === null) return null;
+    logs.push(prepareLogForList(log, includeBodies));
+  }
+
+  return {
+    logs,
+    total: entries.length,
+    offset: options.offset,
+    limit: options.limit,
+  };
+}
+
 export async function listLogsPage(options: ListLogsPageOptions): Promise<ListLogsPageResult> {
+  const indexedPage = await listLogsPageFromIndex(options, true);
+  if (indexedPage !== null) return indexedPage;
+
   const seenIds = new Set<number>();
   const pageById = new Map<number, CapturedLog>();
   const pageStart = options.offset;
   const pageEnd = options.offset + options.limit;
+  const includeBodies = options.includeBodies !== false;
   let total = 0;
 
   const visitLog = (log: CapturedLog): void => {
@@ -400,13 +477,13 @@ export async function listLogsPage(options: ListLogsPageOptions): Promise<ListLo
       const position = total;
       total += 1;
       if (position >= pageStart && position < pageEnd) {
-        pageById.set(log.id, log);
+        pageById.set(log.id, prepareLogForList(log, includeBodies));
       }
       return;
     }
 
     if (pageById.has(log.id)) {
-      pageById.set(log.id, log);
+      pageById.set(log.id, prepareLogForList(log, includeBodies));
     }
   };
 

package/src/routes/api/logs.stream.ts

@@ -1,5 +1,5 @@
 import { createFileRoute } from "@tanstack/react-router";
-import { onLogUpdate, getLogSessionId, listLogsPage } from "../../proxy/store";
+import { compactLogForList, onLogUpdate, getLogSessionId, listLogsPage } from "../../proxy/store";
 import { type CapturedLog } from "../../proxy/schemas";
 
 const INITIAL_STREAM_LOG_LIMIT = 100;
@@ -11,6 +11,7 @@ export const Route = createFileRoute("/api/logs/stream")({
         const url = new URL(request.url);
         const sessionId = url.searchParams.get("sessionId") ?? undefined;
         const model = url.searchParams.get("model") ?? undefined;
+        const includeBodies = url.searchParams.get("compact") !== "1";
 
         let controllerRef: ReadableStreamDefaultController<Uint8Array> | null = null;
         let cleanedUp = false;
@@ -21,7 +22,8 @@ export const Route = createFileRoute("/api/logs/stream")({
           if (sessionId !== undefined && getLogSessionId(log) !== sessionId) return;
           if (model !== undefined && log.model !== model) return;
           try {
-            const data = `data: ${JSON.stringify({ type: "update", log })}\n\n`;
+            const payloadLog = includeBodies ? log : compactLogForList(log);
+            const data = `data: ${JSON.stringify({ type: "update", log: payloadLog })}\n\n`;
             controllerRef.enqueue(new TextEncoder().encode(data));
           } catch {
             cleanup();
@@ -59,6 +61,7 @@ export const Route = createFileRoute("/api/logs/stream")({
               model,
               offset: 0,
               limit: INITIAL_STREAM_LOG_LIMIT,
+              includeBodies,
             });
             const logs = result.logs;
             const initData = `data: ${JSON.stringify({ type: "init", logs })}\n\n`;

package/src/routes/api/logs.ts

@@ -49,8 +49,11 @@ export const Route = createFileRoute("/api/logs")({
         const model = url.searchParams.get("model") ?? undefined;
         const offset = parseNonNegativeInt(url.searchParams.get("offset"), 0);
         const limit = parsePositiveInt(url.searchParams.get("limit"), 50);
+        const includeBodies = url.searchParams.get("compact") !== "1";
 
-        return Response.json(await listLogsPage({ sessionId, model, offset, limit }));
+        return Response.json(
+          await listLogsPage({ sessionId, model, offset, limit, includeBodies }),
+        );
       },
       DELETE: async ({ request }: { request: Request }) => {
         let body: z.infer<typeof DeleteBodySchema> = undefined;