@tonyclaw/agent-inspector 2.0.22 → 2.0.24

package/.output/server/index.mjs

@@ -38,100 +38,100 @@ const assets = {
   "/assets/alibaba-TTwafVwX.svg": {
     "type": "image/svg+xml",
     "etag": '"171b-6dyV5K8QjiaY35sN9qNprh9zDIs"',
-    "mtime": "2026-06-29T10:13:59.057Z",
+    "mtime": "2026-06-29T12:29:42.542Z",
     "size": 5915,
     "path": "../public/assets/alibaba-TTwafVwX.svg"
   },
-  "/assets/index-CUyRKgII.js": {
+  "/assets/CompareDrawer-DrY-gAzy.js": {
     "type": "text/javascript; charset=utf-8",
-    "etag": '"74-Blhwtv0C+J1LFr8yFFBCZDV3zwg"',
-    "mtime": "2026-06-29T10:13:59.057Z",
+    "etag": '"49fe-MpHiIJshHfw4LFDNCsCMDZDrWGg"',
+    "mtime": "2026-06-29T12:29:42.542Z",
+    "size": 18942,
+    "path": "../public/assets/CompareDrawer-DrY-gAzy.js"
+  },
+  "/assets/index-CViEXkqa.js": {
+    "type": "text/javascript; charset=utf-8",
+    "etag": '"74-U7AFlYRRMX3IzoDVXXko4xBPBvM"',
+    "mtime": "2026-06-29T12:29:42.542Z",
     "size": 116,
-    "path": "../public/assets/index-CUyRKgII.js"
+    "path": "../public/assets/index-CViEXkqa.js"
   },
-  "/assets/CompareDrawer-NEdpe1wl.js": {
+  "/assets/ReplayDialog-CFyw6Vu4.js": {
     "type": "text/javascript; charset=utf-8",
-    "etag": '"49fe-y9gn69XtxO5KnrFt7knbaWGcfgk"',
-    "mtime": "2026-06-29T10:13:59.057Z",
-    "size": 18942,
-    "path": "../public/assets/CompareDrawer-NEdpe1wl.js"
+    "etag": '"318c-yVT324FTJnGgK/IiiYVI1v6/IEw"',
+    "mtime": "2026-06-29T12:29:42.542Z",
+    "size": 12684,
+    "path": "../public/assets/ReplayDialog-CFyw6Vu4.js"
+  },
+  "/assets/RequestAnatomy-DHGJ9py7.js": {
+    "type": "text/javascript; charset=utf-8",
+    "etag": '"4485-2C+vaW+lYZaQ0wLkm/KTOsK3AOY"',
+    "mtime": "2026-06-29T12:29:42.542Z",
+    "size": 17541,
+    "path": "../public/assets/RequestAnatomy-DHGJ9py7.js"
   },
   "/assets/minimax-BPMzvuL-.jpeg": {
     "type": "image/jpeg",
     "etag": '"1b06-IwivU89ko5UTMUM1/t7hn4sQK9A"',
-    "mtime": "2026-06-29T10:13:59.057Z",
+    "mtime": "2026-06-29T12:29:42.542Z",
     "size": 6918,
     "path": "../public/assets/minimax-BPMzvuL-.jpeg"
   },
-  "/assets/ReplayDialog-DijzJwaQ.js": {
-    "type": "text/javascript; charset=utf-8",
-    "etag": '"318c-lNBvN0WiZ9zXnNRPUHB9Uc3Q+U4"',
-    "mtime": "2026-06-29T10:13:59.057Z",
-    "size": 12684,
-    "path": "../public/assets/ReplayDialog-DijzJwaQ.js"
-  },
-  "/assets/main-N-sjHJUM.js": {
-    "type": "text/javascript; charset=utf-8",
-    "etag": '"51726-Oiv87HUBZCp4NUFhL1cAZMdsJk4"',
-    "mtime": "2026-06-29T10:13:59.057Z",
-    "size": 333606,
-    "path": "../public/assets/main-N-sjHJUM.js"
-  },
-  "/assets/RequestAnatomy-CYbosGYy.js": {
-    "type": "text/javascript; charset=utf-8",
-    "etag": '"4485-A1lqcM9CzkgAhkltbvT6xUyCtnk"',
-    "mtime": "2026-06-29T10:13:59.057Z",
-    "size": 17541,
-    "path": "../public/assets/RequestAnatomy-CYbosGYy.js"
+  "/assets/index-780zTVwp.css": {
+    "type": "text/css; charset=utf-8",
+    "etag": '"1a380-Lz+Shs13XyKSlh9PTaGE50w/BpU"',
+    "mtime": "2026-06-29T12:29:42.542Z",
+    "size": 107392,
+    "path": "../public/assets/index-780zTVwp.css"
   },
-  "/assets/ResponseView-B3dPM63X.js": {
+  "/assets/ResponseView-CB_3yc08.js": {
     "type": "text/javascript; charset=utf-8",
-    "etag": '"30d0-yf9eD5N2NhQxIYMoH1SUnd4oOgc"',
-    "mtime": "2026-06-29T10:13:59.057Z",
+    "etag": '"30d0-M6AktqEyUeyPg4kcv2fzak6vFlw"',
+    "mtime": "2026-06-29T12:29:42.542Z",
     "size": 12496,
-    "path": "../public/assets/ResponseView-B3dPM63X.js"
+    "path": "../public/assets/ResponseView-CB_3yc08.js"
   },
-  "/assets/StreamingChunkSequence-DYDx3xRY.js": {
+  "/assets/StreamingChunkSequence-CqhHwgDn.js": {
     "type": "text/javascript; charset=utf-8",
-    "etag": '"d57-f9EtnNikrXbuhOm0uN5++yxdqVU"',
-    "mtime": "2026-06-29T10:13:59.057Z",
+    "etag": '"d57-C9p9lFGRMu7L/bxJPes/RpOKks0"',
+    "mtime": "2026-06-29T12:29:42.542Z",
     "size": 3415,
-    "path": "../public/assets/StreamingChunkSequence-DYDx3xRY.js"
+    "path": "../public/assets/StreamingChunkSequence-CqhHwgDn.js"
   },
-  "/assets/index-780zTVwp.css": {
-    "type": "text/css; charset=utf-8",
-    "etag": '"1a380-Lz+Shs13XyKSlh9PTaGE50w/BpU"',
-    "mtime": "2026-06-29T10:13:59.057Z",
-    "size": 107392,
-    "path": "../public/assets/index-780zTVwp.css"
-  },
-  "/assets/_sessionId-b1KDnByv.js": {
+  "/assets/_sessionId-CgG9CQ9r.js": {
     "type": "text/javascript; charset=utf-8",
-    "etag": '"d2-2mMUMRPxx6mDkse9IY1TOO0xQxM"',
-    "mtime": "2026-06-29T10:13:59.057Z",
+    "etag": '"d2-QqZWnWujfEY0vnXMOs1NyoEJukI"',
+    "mtime": "2026-06-29T12:29:42.542Z",
     "size": 210,
-    "path": "../public/assets/_sessionId-b1KDnByv.js"
+    "path": "../public/assets/_sessionId-CgG9CQ9r.js"
   },
   "/assets/zhipuai-BPNAnxo-.svg": {
     "type": "image/svg+xml",
     "etag": '"2bf8-hNaLCTi89nOFCsIIfWpP/jrfo0s"',
-    "mtime": "2026-06-29T10:13:59.057Z",
+    "mtime": "2026-06-29T12:29:42.542Z",
     "size": 11256,
     "path": "../public/assets/zhipuai-BPNAnxo-.svg"
   },
+  "/assets/main-CVw7-JyE.js": {
+    "type": "text/javascript; charset=utf-8",
+    "etag": '"51726-W+9s8t7uIYMEgBdKzOagDvVRdKc"',
+    "mtime": "2026-06-29T12:29:42.542Z",
+    "size": 333606,
+    "path": "../public/assets/main-CVw7-JyE.js"
+  },
   "/assets/qwen-CONDcHqt.png": {
     "type": "image/png",
     "etag": '"572c3-cdJAPaHdOvFCGzuaQjagdgOu6XE"',
-    "mtime": "2026-06-29T10:13:59.057Z",
+    "mtime": "2026-06-29T12:29:42.542Z",
     "size": 357059,
     "path": "../public/assets/qwen-CONDcHqt.png"
   },
-  "/assets/ProxyViewerContainer-Dwhi4Q1c.js": {
+  "/assets/ProxyViewerContainer-CiLvRNie.js": {
     "type": "text/javascript; charset=utf-8",
-    "etag": '"adfba-7oCIiP/M+eYpRHnO3/abH2UghkE"',
-    "mtime": "2026-06-29T10:13:59.058Z",
-    "size": 712634,
-    "path": "../public/assets/ProxyViewerContainer-Dwhi4Q1c.js"
+    "etag": '"ae3c0-Cpzx6KeaKuGDUgS/cMjRV9y+6zQ"',
+    "mtime": "2026-06-29T12:29:42.542Z",
+    "size": 713664,
+    "path": "../public/assets/ProxyViewerContainer-CiLvRNie.js"
   }
 };
 function readAsset(id) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tonyclaw/agent-inspector",
-  "version": "2.0.22",
+  "version": "2.0.24",
   "type": "module",
   "description": "Agent observability and knowledge capture layer for AI coding tools.",
   "license": "MIT",

package/src/components/ProxyViewer.tsx

@@ -637,6 +637,7 @@ export function ProxyViewer({
   const { totalIn, totalOut } = useMemo(() => computeTokenSummary(logs), [logs]);
   const { providers } = useProviders();
   const [exporting, setExporting] = useState<ExportMode | null>(null);
+  const [exportError, setExportError] = useState<string | null>(null);
   const [comparePair, setComparePair] = useState<[CapturedLog, CapturedLog] | null>(null);
   const [crabEntrancePhase, setCrabEntrancePhase] = useState<"hidden" | "playing" | "done">(
     "hidden",
@@ -669,8 +670,12 @@ export function ProxyViewer({
   const handleExport = useCallback(
     async (mode: ExportMode) => {
       setExporting(mode);
+      setExportError(null);
       try {
-        await exportLogsAsZip(logs, mode);
+        const result = await exportLogsAsZip(logs, mode);
+        if (!result.ok) {
+          setExportError(result.message);
+        }
       } finally {
         setExporting(null);
       }
@@ -908,6 +913,11 @@ export function ProxyViewer({
             Clear
           </button>
         </div>
+        {exportError !== null && (
+          <div className="mb-4 rounded-md border border-destructive/30 bg-destructive/10 px-3 py-2 text-xs text-destructive">
+            {exportError}
+          </div>
+        )}
       </div>
 
       {/* Log list */}

package/src/components/ProxyViewerContainer.tsx

@@ -64,6 +64,7 @@ function filterLogs(
 const DEBOUNCE_MS = 50;
 const HASH_SCROLL_ATTEMPTS = 12;
 const HASH_HIGHLIGHT_MS = 1800;
+const MAX_CLIENT_LOGS = 500;
 
 function buildLogsStreamUrl(sessionId: string | undefined): string {
   if (sessionId === undefined) return "/api/logs/stream";
@@ -71,6 +72,20 @@ function buildLogsStreamUrl(sessionId: string | undefined): string {
   return `/api/logs/stream?${params.toString()}`;
 }
 
+function buildLogIndex(logs: readonly CapturedLog[]): Map<number, number> {
+  const idx = new Map<number, number>();
+  for (let i = 0; i < logs.length; i++) {
+    const log = logs[i];
+    if (log !== undefined) idx.set(log.id, i);
+  }
+  return idx;
+}
+
+function trimClientLogs(logs: CapturedLog[]): CapturedLog[] {
+  if (logs.length <= MAX_CLIENT_LOGS) return logs;
+  return logs.slice(logs.length - MAX_CLIENT_LOGS);
+}
+
 export function ProxyViewerContainer({
   initialSessionId,
 }: {
@@ -132,6 +147,8 @@ export function ProxyViewerContainer({
           next = [...next, log];
         }
       }
+      next = trimClientLogs(next);
+      logIndexRef.current = buildLogIndex(next);
       return next;
     });
   }, []);
@@ -173,14 +190,9 @@ export function ProxyViewerContainer({
           }
           pendingUpdatesRef.current = [];
 
-          // Build fresh index
-          const idx = new Map<number, number>();
-          for (let i = 0; i < update.logs.length; i++) {
-            const log = update.logs[i];
-            if (log !== undefined) idx.set(log.id, i);
-          }
-          logIndexRef.current = idx;
-          setAllLogs(update.logs);
+          const nextLogs = trimClientLogs(update.logs);
+          logIndexRef.current = buildLogIndex(nextLogs);
+          setAllLogs(nextLogs);
           setError(null);
         } else if (update.type === "update") {
           scheduleUpdate(update.log);
@@ -317,13 +329,7 @@ export function ProxyViewerContainer({
         const idSet = new Set(ids);
         setAllLogs((prev) => {
           const remaining = prev.filter((l) => !idSet.has(l.id));
-          // Rebuild index
-          const idx = new Map<number, number>();
-          for (let i = 0; i < remaining.length; i++) {
-            const log = remaining[i];
-            if (log !== undefined) idx.set(log.id, i);
-          }
-          logIndexRef.current = idx;
+          logIndexRef.current = buildLogIndex(remaining);
           return remaining;
         });
         setError(null);

package/src/lib/export-logs.ts

@@ -2,6 +2,12 @@ import JSZip from "jszip";
 import type { CapturedLog } from "../proxy/schemas";
 
 export type ExportMode = "redacted" | "raw";
+export type ExportLogsResult =
+  | { ok: true }
+  | {
+      ok: false;
+      message: string;
+    };
 
 const REDACTED = "[REDACTED]";
 const SECRET_KEY_PATTERN =
@@ -13,6 +19,39 @@ const SECRET_TEXT_PATTERNS: readonly RegExp[] = [
   /\bghp_[A-Za-z0-9_]{12,}\b/g,
   /\bglpat-[A-Za-z0-9_-]{12,}\b/g,
 ];
+const MAX_EXPORT_LOGS = 200;
+const MAX_EXPORT_TEXT_CHARS = 25_000_000;
+const MAX_STREAMING_CHUNK_EXPORTS = 50;
+
+function formatApproxSize(chars: number): string {
+  if (chars < 1024) return `${chars} chars`;
+  if (chars < 1024 * 1024) return `${Math.ceil(chars / 1024)} KB`;
+  return `${Math.ceil(chars / (1024 * 1024))} MB`;
+}
+
+function estimateExportTextChars(logs: readonly CapturedLog[]): number {
+  let total = 0;
+  for (const log of logs) {
+    total += log.rawRequestBody?.length ?? 0;
+    total += log.responseText?.length ?? 0;
+  }
+  return total;
+}
+
+function exportLimitMessage(logs: readonly CapturedLog[]): string | null {
+  if (logs.length > MAX_EXPORT_LOGS) {
+    return `Export is limited to ${MAX_EXPORT_LOGS} logs at once. Narrow the filter and try again.`;
+  }
+
+  const estimatedChars = estimateExportTextChars(logs);
+  if (estimatedChars > MAX_EXPORT_TEXT_CHARS) {
+    return `Export is too large (${formatApproxSize(
+      estimatedChars,
+    )} of text). Narrow the filter and try again.`;
+  }
+
+  return null;
+}
 
 async function fetchStreamingChunks(logId: number): Promise<string | null> {
   try {
@@ -64,9 +103,13 @@ function exportText(text: string, mode: ExportMode): string {
 export async function exportLogsAsZip(
   logs: CapturedLog[],
   mode: ExportMode = "redacted",
-): Promise<void> {
+): Promise<ExportLogsResult> {
+  const limitMessage = exportLimitMessage(logs);
+  if (limitMessage !== null) return { ok: false, message: limitMessage };
+
   const zip = new JSZip();
   const suffix = mode === "redacted" ? "redacted" : "raw";
+  const streamingLogs = logs.filter((log) => log.streaming).slice(0, MAX_STREAMING_CHUNK_EXPORTS);
   zip.file(
     "manifest.json",
     JSON.stringify(
@@ -76,6 +119,8 @@ export async function exportLogsAsZip(
         redacted: mode === "redacted",
         logCount: logs.length,
         logIds: logs.map((log) => log.id),
+        streamingChunkExportLimit: MAX_STREAMING_CHUNK_EXPORTS,
+        streamingChunkLogIds: streamingLogs.map((log) => log.id),
       },
       null,
       2,
@@ -92,16 +137,13 @@ export async function exportLogsAsZip(
     }
   }
 
-  // Fetch SSE chunks in parallel for streaming logs
-  const streamingLogs = logs.filter((log) => log.streaming);
-  await Promise.allSettled(
-    streamingLogs.map(async (log) => {
-      const chunks = await fetchStreamingChunks(log.id);
-      if (chunks !== null) {
-        zip.file(`#${log.id}.SSE.Response.json`, exportText(chunks, mode));
-      }
-    }),
-  );
+  // Fetch SSE chunks sequentially so exports do not spike browser memory.
+  for (const log of streamingLogs) {
+    const chunks = await fetchStreamingChunks(log.id);
+    if (chunks !== null) {
+      zip.file(`#${log.id}.SSE.Response.json`, exportText(chunks, mode));
+    }
+  }
 
   // Generate and download ZIP
   const blob = await zip.generateAsync({ type: "blob" });
@@ -115,4 +157,5 @@ export async function exportLogsAsZip(
   document.body.removeChild(anchor);
 
   URL.revokeObjectURL(url);
+  return { ok: true };
 }

package/src/lib/providerTestPrompt.ts

@@ -9,7 +9,7 @@ export type ProviderTestRequestBody = {
   model: string;
   messages: ProviderTestMessage[];
   max_tokens: number;
-  stream?: true;
+  stream: boolean;
 };
 
 const MEMORY_PROBE_FACTS = [
@@ -32,9 +32,9 @@ function modeInstruction(mode: ProviderTestMode): string {
 function maxTokensForMode(mode: ProviderTestMode): number {
   switch (mode) {
     case "non-streaming":
-      return 1024;
+      return 256;
     case "streaming":
-      return 384;
+      return 256;
   }
 }
 
@@ -71,7 +71,7 @@ export function buildProviderTestRequestBody(
   };
   switch (mode) {
     case "non-streaming":
-      return base;
+      return { ...base, stream: false };
     case "streaming":
       return { ...base, stream: true };
   }

package/src/mcp/toolHandlers.ts

@@ -13,12 +13,13 @@
  * `isError: true` results from inside the impl.
  */
 
+import { Buffer } from "node:buffer";
 import { z } from "zod";
 import { LoopbackTimeoutError, type CallApiOptions } from "./loopback";
 import { extractLastUserMessagePreview, extractResponsePreview } from "./previewExtractor";
 import { CapturedLogSchema, type CapturedLog } from "../proxy/schemas";
 
-/** Minimal callApi contract — same shape as the real `callApi` in loopback.ts. */
+/** Minimal callApi contract: same shape as the real `callApi` in loopback.ts. */
 export type CallApiFn = (path: string, options?: CallApiOptions) => Promise<Response>;
 
 export type ToolResult = {
@@ -26,7 +27,7 @@ export type ToolResult = {
   isError?: true;
 };
 
-// Loose shape returned by `GET /api/logs` — `logs: CapturedLog[]` and a few
+// Loose shape returned by `GET /api/logs`: `logs: CapturedLog[]` and a few
 // pagination fields. The CapturedLog items are fully validated downstream.
 const LogsListResponseSchema = z.object({
   logs: z.array(CapturedLogSchema).optional(),
@@ -37,6 +38,7 @@ const LogsListResponseSchema = z.object({
 
 const PAGINATION_DEFAULTS = { offset: 0, limit: 3 };
 export const LIMIT_HARD_CAP = 5;
+const LOG_DETAIL_TEXT_LIMIT = 200_000;
 
 export function clampLimit(input: number | undefined): number {
   if (input === undefined) return PAGINATION_DEFAULTS.limit;
@@ -52,10 +54,55 @@ function toolError(message: string): ToolResult {
   return { content: [{ type: "text", text: message }], isError: true };
 }
 
+function textByteLength(value: string | null): number | null {
+  if (value === null) return null;
+  return Buffer.byteLength(value, "utf8");
+}
+
+function hasBodyText(value: string | null, byteLength: number | null | undefined): boolean {
+  if (value !== null && value.length > 0) return true;
+  return byteLength !== undefined && byteLength !== null && byteLength > 0;
+}
+
+function truncateToolText(value: string | null): {
+  value: string | null;
+  byteLength: number | null;
+  truncated: boolean;
+} {
+  if (value === null) return { value: null, byteLength: null, truncated: false };
+  const byteLength = textByteLength(value);
+  if (value.length <= LOG_DETAIL_TEXT_LIMIT) {
+    return { value, byteLength, truncated: false };
+  }
+  const suffix = `\n[truncated by agent-inspector MCP: original ${byteLength ?? 0} bytes]`;
+  return {
+    value: `${value.slice(0, LOG_DETAIL_TEXT_LIMIT)}${suffix}`,
+    byteLength,
+    truncated: true,
+  };
+}
+
+function buildBoundedLogDetail(log: CapturedLog): Record<string, unknown> {
+  const { streamingChunks: _chunks, rawRequestBody, responseText, ...rest } = log;
+  const boundedRequest = truncateToolText(rawRequestBody);
+  const boundedResponse = truncateToolText(responseText);
+  return {
+    ...rest,
+    rawRequestBody: boundedRequest.value,
+    responseText: boundedResponse.value,
+    rawRequestBodyBytes: boundedRequest.byteLength,
+    responseTextBytes: boundedResponse.byteLength,
+    rawRequestBodyTruncated: boundedRequest.truncated,
+    responseTextTruncated: boundedResponse.truncated,
+  };
+}
+
 export function buildLogSummary(log: CapturedLog) {
   const hasError =
     (log.error !== null && log.error !== undefined && log.error.length > 0) ||
     (log.responseStatus !== null && log.responseStatus !== undefined && log.responseStatus >= 400);
+  const rawRequestBodyBytes = log.rawRequestBodyBytes ?? textByteLength(log.rawRequestBody);
+  const responseTextBytes = log.responseTextBytes ?? textByteLength(log.responseText);
   return {
     id: log.id,
     timestamp: log.timestamp,
@@ -81,7 +128,9 @@ export function buildLogSummary(log: CapturedLog) {
     hasChunks:
       (log.streamingChunks !== undefined && log.streamingChunks !== null) ||
       (log.streamingChunksPath !== null && log.streamingChunksPath !== undefined),
-    hasRawRequestBody: log.rawRequestBody !== null && log.rawRequestBody !== undefined,
+    hasRawRequestBody: hasBodyText(log.rawRequestBody, rawRequestBodyBytes),
+    rawRequestBodyBytes,
+    responseTextBytes,
   };
 }
 
@@ -99,7 +148,11 @@ export type ListLogsArgs = {
 export async function listLogsImpl(callApi: CallApiFn, args: ListLogsArgs): Promise<ToolResult> {
   const offset = args.offset ?? PAGINATION_DEFAULTS.offset;
   const limit = clampLimit(args.limit);
-  const params = new URLSearchParams({ offset: String(offset), limit: String(limit) });
+  const params = new URLSearchParams({
+    offset: String(offset),
+    limit: String(limit),
+    compact: "1",
+  });
   if (args.sessionId !== undefined && args.sessionId.length > 0) {
     params.set("sessionId", args.sessionId);
   }
@@ -123,10 +176,7 @@ export async function getLogImpl(callApi: CallApiFn, id: number): Promise<ToolRe
   if (!parsed.success) {
     return toolError(`GET /api/logs/${id} returned an unparseable CapturedLog`);
   }
-  // Strip streamingChunks per design D6 — the agent asks for chunks
-  // explicitly via inspector_get_log_chunks.
-  const { streamingChunks: _chunks, ...rest } = parsed.data;
-  return textJson(rest);
+  return textJson(buildBoundedLogDetail(parsed.data));
 }
 
 export async function getLogChunksImpl(callApi: CallApiFn, id: number): Promise<ToolResult> {

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(),
 });