@tonyclaw/agent-inspector 2.0.23 → 2.0.25

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/components/providers/ProviderForm.tsx

@@ -1,9 +1,11 @@
 import { type JSX, useState, useEffect, useRef } from "react";
 import { Button } from "../ui/button";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "../ui/select";
 import { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider } from "../ui/tooltip";
 import { Eye, EyeOff, Copy, Check, ChevronDown } from "lucide-react";
 import type { ProviderConfig, ProviderModelMetadata } from "../../lib/providerContract";
 import { maskApiKey } from "../../lib/mask";
+import { formatContextWindowInput, parseContextWindowTokensInput } from "../../lib/utils";
 
 const ZHIPU_PROVIDER_KEYWORDS = ["zhipu", "zhipuai", "bigmodel", "z.ai", "zai", "glm"];
 const ZHIPU_CODING_PROVIDER_KEYWORDS = [
@@ -129,11 +131,29 @@ type ProviderFormProps = {
 
 type ModelMetadataDraft = {
   contextWindow: string;
+  contextWindowMode: ContextWindowMode;
   outputLimit: string;
 };
 
+type ContextWindowMode = "unset" | "preset" | "custom";
+
+type ContextWindowUnit = "K" | "M" | "tokens";
+
+const CONTEXT_WINDOW_UNSET = "__unset__";
+const CONTEXT_WINDOW_CUSTOM = "__custom__";
+
+const CONTEXT_WINDOW_PRESETS = [
+  { value: "32K", label: "Small" },
+  { value: "64K", label: "Standard" },
+  { value: "128K", label: "Medium" },
+  { value: "200K", label: "Long" },
+  { value: "256K", label: "Extended" },
+  { value: "512K", label: "Large" },
+  { value: "1M", label: "Max" },
+];
+
 function emptyMetadataDraft(): ModelMetadataDraft {
-  return { contextWindow: "", outputLimit: "" };
+  return { contextWindow: "", contextWindowMode: "unset", outputLimit: "" };
 }
 
 function normalizeModelName(value: string): string {
@@ -152,14 +172,74 @@ function findModelMetadata(
   );
 }
 
+function findContextWindowPreset(value: string): string | null {
+  const tokens = parseContextWindowTokensInput(value);
+  if (tokens === null) return null;
+  for (const preset of CONTEXT_WINDOW_PRESETS) {
+    if (parseContextWindowTokensInput(preset.value) === tokens) return preset.value;
+  }
+  return null;
+}
+
+function contextWindowModeForValue(value: string): ContextWindowMode {
+  if (value.trim() === "") return "unset";
+  return findContextWindowPreset(value) !== null ? "preset" : "custom";
+}
+
+function selectedContextWindowPresetValue(draft: ModelMetadataDraft): string {
+  switch (draft.contextWindowMode) {
+    case "unset":
+      return CONTEXT_WINDOW_UNSET;
+    case "custom":
+      return CONTEXT_WINDOW_CUSTOM;
+    case "preset":
+      return findContextWindowPreset(draft.contextWindow) ?? CONTEXT_WINDOW_CUSTOM;
+  }
+}
+
+function splitContextWindowEditorValue(value: string): { amount: string; unit: ContextWindowUnit } {
+  const trimmed = value.trim().replaceAll(",", "");
+  if (trimmed === "") return { amount: "", unit: "K" };
+  const match = /^(\d+(?:\.\d+)?)\s*([kKmM])?$/.exec(trimmed);
+  if (match === null) return { amount: trimmed, unit: "K" };
+  const amount = match[1];
+  if (amount === undefined) return { amount: trimmed, unit: "K" };
+  const unit = match[2];
+  if (unit === undefined || unit === "") return { amount, unit: "tokens" };
+  switch (unit.toLowerCase()) {
+    case "k":
+      return { amount, unit: "K" };
+    case "m":
+      return { amount, unit: "M" };
+    default:
+      return { amount: trimmed, unit: "K" };
+  }
+}
+
+function joinContextWindowEditorValue(amount: string, unit: ContextWindowUnit): string {
+  const trimmed = amount.trim();
+  if (trimmed === "") return "";
+  switch (unit) {
+    case "K":
+      return `${trimmed}K`;
+    case "M":
+      return `${trimmed}M`;
+    case "tokens":
+      return trimmed;
+  }
+}
+
 function createMetadataDrafts(
   provider: ProviderConfig | undefined,
   models: readonly string[],
 ): ModelMetadataDraft[] {
   return models.map((model) => {
     const metadata = findModelMetadata(provider, model);
+    const contextWindow =
+      metadata?.contextWindow !== undefined ? formatContextWindowInput(metadata.contextWindow) : "";
     return {
-      contextWindow: metadata?.contextWindow?.toString() ?? "",
+      contextWindow,
+      contextWindowMode: contextWindowModeForValue(contextWindow),
       outputLimit: metadata?.outputLimit?.toString() ?? "",
     };
   });
@@ -315,11 +395,11 @@ export function ProviderForm({ provider, onSubmit, onCancel }: ProviderFormProps
       newErrors.modelMetadataUrl = "Invalid URL format";
     }
     modelMetadataDrafts.forEach((draft, index) => {
-      const contextWindow = readPositiveIntegerInput(draft.contextWindow);
+      const contextWindow = parseContextWindowTokensInput(draft.contextWindow);
       const outputLimit = readPositiveIntegerInput(draft.outputLimit);
       if (draft.contextWindow.trim() !== "" && contextWindow === null) {
         newErrors[`modelMetadata.${index}.contextWindow`] =
-          "Context window must be a positive integer";
+          "Context window must be a positive number, optionally using K or M";
       }
       if (draft.outputLimit.trim() !== "" && outputLimit === null) {
         newErrors[`modelMetadata.${index}.outputLimit`] = "Output limit must be a positive integer";
@@ -361,6 +441,51 @@ export function ProviderForm({ provider, onSubmit, onCancel }: ProviderFormProps
     });
   }
 
+  function updateContextWindowPreset(index: number, value: string): void {
+    switch (value) {
+      case CONTEXT_WINDOW_UNSET:
+        updateMetadataDraft(index, { contextWindow: "", contextWindowMode: "unset" });
+        return;
+      case CONTEXT_WINDOW_CUSTOM: {
+        const current = modelMetadataDrafts[index] ?? emptyMetadataDraft();
+        updateMetadataDraft(index, {
+          contextWindow: current.contextWindow,
+          contextWindowMode: "custom",
+        });
+        return;
+      }
+      default:
+        updateMetadataDraft(index, { contextWindow: value, contextWindowMode: "preset" });
+        return;
+    }
+  }
+
+  function updateContextWindowAmount(index: number, amount: string): void {
+    const current = modelMetadataDrafts[index] ?? emptyMetadataDraft();
+    const editorValue = splitContextWindowEditorValue(current.contextWindow);
+    updateMetadataDraft(index, {
+      contextWindow: joinContextWindowEditorValue(amount, editorValue.unit),
+      contextWindowMode: "custom",
+    });
+  }
+
+  function updateContextWindowUnit(index: number, unit: string): void {
+    const current = modelMetadataDrafts[index] ?? emptyMetadataDraft();
+    const editorValue = splitContextWindowEditorValue(current.contextWindow);
+    switch (unit) {
+      case "K":
+      case "M":
+      case "tokens":
+        updateMetadataDraft(index, {
+          contextWindow: joinContextWindowEditorValue(editorValue.amount, unit),
+          contextWindowMode: "custom",
+        });
+        return;
+      default:
+        return;
+    }
+  }
+
   function removeModel(index: number): void {
     setModels((prev) => prev.filter((_, idx) => idx !== index));
     setModelMetadataDrafts((prev) => prev.filter((_, idx) => idx !== index));
@@ -379,7 +504,7 @@ export function ProviderForm({ provider, onSubmit, onCancel }: ProviderFormProps
       const trimmedModel = model.trim();
       if (trimmedModel === "") return;
       const draft = modelMetadataDrafts[index] ?? emptyMetadataDraft();
-      const contextWindow = readPositiveIntegerInput(draft.contextWindow);
+      const contextWindow = parseContextWindowTokensInput(draft.contextWindow);
       const outputLimit = readPositiveIntegerInput(draft.outputLimit);
       if (contextWindow === null && outputLimit === null) return;
 
@@ -548,6 +673,8 @@ export function ProviderForm({ provider, onSubmit, onCancel }: ProviderFormProps
           const draft = modelMetadataDrafts[i] ?? emptyMetadataDraft();
           const contextWindowError = errors[`modelMetadata.${i}.contextWindow`];
           const outputLimitError = errors[`modelMetadata.${i}.outputLimit`];
+          const contextWindowPresetValue = selectedContextWindowPresetValue(draft);
+          const contextWindowEditorValue = splitContextWindowEditorValue(draft.contextWindow);
           return (
             <div
               key={i}
@@ -624,21 +751,54 @@ export function ProviderForm({ provider, onSubmit, onCancel }: ProviderFormProps
               </div>
 
               <div className="grid gap-2 sm:grid-cols-2">
-                <label className="space-y-1 text-xs text-muted-foreground">
+                <div className="space-y-1 text-xs text-muted-foreground">
                   <span>Context Window</span>
-                  <input
-                    type="number"
-                    min={1}
-                    step={1000}
-                    value={draft.contextWindow}
-                    onChange={(e) => updateMetadataDraft(i, { contextWindow: e.target.value })}
-                    placeholder="e.g. 1048576"
-                    className="w-full rounded-md border border-input bg-background px-3 py-2 font-mono text-xs text-foreground ring-offset-background placeholder:text-muted-foreground focus-visible:border-ring focus-visible:outline-ring focus-visible:ring-[3px]"
-                  />
+                  <Select
+                    value={contextWindowPresetValue}
+                    onValueChange={(value) => updateContextWindowPreset(i, value)}
+                  >
+                    <SelectTrigger size="sm" className="w-full bg-background font-mono text-xs">
+                      <SelectValue />
+                    </SelectTrigger>
+                    <SelectContent className="max-h-64">
+                      <SelectItem value={CONTEXT_WINDOW_UNSET}>Not set</SelectItem>
+                      {CONTEXT_WINDOW_PRESETS.map((preset) => (
+                        <SelectItem key={preset.value} value={preset.value}>
+                          {preset.label} · {preset.value}
+                        </SelectItem>
+                      ))}
+                      <SelectItem value={CONTEXT_WINDOW_CUSTOM}>Custom</SelectItem>
+                    </SelectContent>
+                  </Select>
+                  {draft.contextWindowMode === "custom" && (
+                    <div className="grid grid-cols-[minmax(0,1fr)_5.75rem] gap-1.5">
+                      <input
+                        type="text"
+                        inputMode="decimal"
+                        value={contextWindowEditorValue.amount}
+                        onChange={(e) => updateContextWindowAmount(i, e.target.value)}
+                        placeholder="128"
+                        className="w-full rounded-md border border-input bg-background px-3 py-2 font-mono text-xs text-foreground ring-offset-background placeholder:text-muted-foreground focus-visible:border-ring focus-visible:outline-ring focus-visible:ring-[3px]"
+                      />
+                      <Select
+                        value={contextWindowEditorValue.unit}
+                        onValueChange={(value) => updateContextWindowUnit(i, value)}
+                      >
+                        <SelectTrigger size="sm" className="w-full bg-background font-mono text-xs">
+                          <SelectValue />
+                        </SelectTrigger>
+                        <SelectContent>
+                          <SelectItem value="K">K</SelectItem>
+                          <SelectItem value="M">M</SelectItem>
+                          <SelectItem value="tokens">tokens</SelectItem>
+                        </SelectContent>
+                      </Select>
+                    </div>
+                  )}
                   {contextWindowError !== undefined && (
                     <span className="block text-destructive">{contextWindowError}</span>
                   )}
-                </label>
+                </div>
                 <label className="space-y-1 text-xs text-muted-foreground">
                   <span>Output Limit</span>
                   <input

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/lib/utils.ts

@@ -17,6 +17,52 @@ export function formatContextWindowTokens(count: number): string {
   return (count / 1024).toFixed(1).replace(/\.0$/, "") + "K";
 }
 
+function formatExactContextUnit(count: number, multiplier: number, unit: "K" | "M"): string | null {
+  const tenths = count * 10;
+  if (!Number.isSafeInteger(tenths) || tenths % multiplier !== 0) return null;
+  return (tenths / multiplier / 10).toFixed(1).replace(/\.0$/, "") + unit;
+}
+
+export function formatContextWindowInput(count: number): string {
+  if (!Number.isSafeInteger(count) || count <= 0) return count.toString();
+  if (count >= 1024 * 1024) {
+    const megaValue = formatExactContextUnit(count, 1024 * 1024, "M");
+    if (megaValue !== null) return megaValue;
+  }
+  const kiloValue = formatExactContextUnit(count, 1024, "K");
+  if (kiloValue !== null) return kiloValue;
+  return count.toString();
+}
+
+function contextWindowUnitMultiplier(unit: string | undefined): number | null {
+  if (unit === undefined || unit === "") return 1;
+  switch (unit.toLowerCase()) {
+    case "k":
+      return 1024;
+    case "m":
+      return 1024 * 1024;
+    default:
+      return null;
+  }
+}
+
+export function parseContextWindowTokensInput(value: string): number | null {
+  const trimmed = value.trim().replaceAll(",", "");
+  if (trimmed === "") return null;
+  const match = /^(\d+(?:\.\d+)?)\s*([kKmM])?$/.exec(trimmed);
+  if (match === null) return null;
+  const amountText = match[1];
+  if (amountText === undefined) return null;
+  const amount = Number(amountText);
+  const unit = match[2];
+  const multiplier = contextWindowUnitMultiplier(unit);
+  if (!Number.isFinite(amount) || amount <= 0 || multiplier === null) return null;
+  if ((unit === undefined || unit === "") && !Number.isInteger(amount)) return null;
+  const tokens = Math.round(amount * multiplier);
+  if (!Number.isSafeInteger(tokens) || tokens <= 0) return null;
+  return tokens;
+}
+
 export type StatusCategory = "success" | "client_error" | "server_error" | "pending";
 
 export function getStatusCategory(status: number | null): StatusCategory {

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> {