@tonyclaw/agent-inspector 2.1.3 → 2.1.4

package/src/components/proxy-viewer/LogEntry.tsx

@@ -1,8 +1,13 @@
 import { AlertTriangle, GitCompareArrows } from "lucide-react";
 import { Suspense, type JSX, type ReactNode } from "react";
 import { useCallback, useEffect, useMemo, useRef, useState, memo } from "react";
-import { CapturedLogSchema, type CapturedLog } from "../../contracts";
-import { fetchJson } from "../../lib/apiClient";
+import {
+  CapturedLogSchema,
+  LogBodyChunkSchema,
+  type CapturedLog,
+  type LogBodyPart,
+} from "../../contracts";
+import { ApiTimeoutError, fetchJsonWithTimeout } from "../../lib/apiClient";
 import type { TimeDisplayFormat } from "../../lib/runtimeConfig";
 import { cn } from "../../lib/utils";
 import { stripClaudeCodeBillingHeader } from "../../proxy/claudeCodeStrip";
@@ -53,14 +58,78 @@ function resolveFocusedTab(tab: LogFocusTab, anatomySegments: AnatomySegment[] |
 }
 
 type BodyHydrationState = "idle" | "loading" | "failed";
+type BodyChunkState = "idle" | "loading" | "success" | "failed";
+
+type BodyPreviewState = {
+  status: BodyChunkState;
+  text: string;
+  offset: number;
+  totalBytes: number | null;
+  hasMore: boolean;
+  error: string | null;
+};
+
+const FULL_LOG_HYDRATION_TIMEOUT_MS = 15_000;
+const BODY_CHUNK_TIMEOUT_MS = 15_000;
+const BODY_CHUNK_BYTES = 256 * 1024;
+const CHUNKED_BODY_THRESHOLD_BYTES = 1024 * 1024;
 
 const TAB_TRIGGER_CLASS =
   "h-9 flex-none rounded-none border-0 border-b-2 border-transparent bg-transparent px-3 text-xs font-semibold text-muted-foreground shadow-none hover:bg-cyan-400/[0.04] hover:text-foreground data-[state=active]:border-cyan-300 data-[state=active]:bg-transparent data-[state=active]:text-cyan-100 data-[state=active]:shadow-none";
 
-function shouldHydrateLogBody(log: CapturedLog): boolean {
+function createEmptyBodyPreviewState(totalBytes: number | null = null): BodyPreviewState {
+  return {
+    status: "idle",
+    text: "",
+    offset: 0,
+    totalBytes,
+    hasMore: totalBytes !== null && totalBytes > 0,
+    error: null,
+  };
+}
+
+function bodyByteCount(value: number | null | undefined): number {
+  return value ?? 0;
+}
+
+function isCompactBody(log: CapturedLog): boolean {
   return log.bodyContentMode === "compact" || log.bodyContentMode === "truncated";
 }
 
+function shouldUseChunkedBodyLoading(log: CapturedLog): boolean {
+  if (!isCompactBody(log)) return false;
+  return (
+    bodyByteCount(log.rawRequestBodyBytes) > CHUNKED_BODY_THRESHOLD_BYTES ||
+    bodyByteCount(log.responseTextBytes) > CHUNKED_BODY_THRESHOLD_BYTES
+  );
+}
+
+function shouldHydrateLogBody(log: CapturedLog): boolean {
+  return isCompactBody(log) && !shouldUseChunkedBodyLoading(log);
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes < 1024) return `${bytes.toLocaleString()} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KiB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MiB`;
+  return `${(bytes / 1024 / 1024 / 1024).toFixed(1)} GiB`;
+}
+
+function bodyPreviewErrorMessage(error: unknown): string {
+  if (error instanceof ApiTimeoutError) {
+    return "Body preview timed out. The log is still available on disk; try loading again.";
+  }
+  if (error instanceof Error) return error.message;
+  return "Body preview could not be loaded.";
+}
+
+function bodyPreviewTextForView(enabled: boolean, state: BodyPreviewState): string | null {
+  if (!enabled) return null;
+  if (state.text !== "") return state.text;
+  if (state.status === "success") return "";
+  return null;
+}
+
 function ExpandedPanel({
   children,
   className,
@@ -126,6 +195,53 @@ function NoticeBlock({
   );
 }
 
+function BodyPreviewNotice({
+  label,
+  state,
+  expectedBytes,
+  onLoadMore,
+}: {
+  label: string;
+  state: BodyPreviewState;
+  expectedBytes: number | null;
+  onLoadMore: () => void;
+}): JSX.Element {
+  const totalBytes = state.totalBytes ?? expectedBytes;
+  const loadedLabel =
+    totalBytes === null
+      ? formatBytes(state.offset)
+      : `${formatBytes(state.offset)} / ${formatBytes(totalBytes)}`;
+  const showLoadMore = state.status !== "loading" && state.hasMore;
+  const actionLabel = state.status === "failed" ? "Retry" : "Load more";
+
+  return (
+    <NoticeBlock
+      tone={state.status === "failed" ? "warning" : "loading"}
+      title={`${label} body preview`}
+    >
+      <div className="flex flex-wrap items-center justify-between gap-2">
+        <span>
+          {state.status === "idle" && totalBytes !== null
+            ? `${label} body is ${formatBytes(totalBytes)}. Loading the first preview chunk.`
+            : `Loaded ${loadedLabel}.`}
+          {state.status === "failed" && state.error !== null && ` ${state.error}`}
+        </span>
+        {showLoadMore && (
+          <Button
+            type="button"
+            variant="outline"
+            size="sm"
+            className="h-7 border-white/10 bg-black/20 text-xs text-cyan-100 hover:border-cyan-300/35 hover:bg-cyan-400/10"
+            onClick={onLoadMore}
+          >
+            {actionLabel}
+          </Button>
+        )}
+      </div>
+    </NoticeBlock>
+  );
+}
+
 function HeaderRows({
   headers,
   emptyLabel,
@@ -260,8 +376,30 @@ export const LogEntry = memo(function ({
   const [expandToPath, setExpandToPath] = useState<string | null>(null);
   const [hydratedLog, setHydratedLog] = useState<CapturedLog | null>(null);
   const [bodyHydrationState, setBodyHydrationState] = useState<BodyHydrationState>("idle");
+  const [requestPreview, setRequestPreview] = useState<BodyPreviewState>(() =>
+    createEmptyBodyPreviewState(log.rawRequestBodyBytes ?? null),
+  );
+  const [responsePreview, setResponsePreview] = useState<BodyPreviewState>(() =>
+    createEmptyBodyPreviewState(log.responseTextBytes ?? null),
+  );
   const requestJsonRef = useRef<HTMLDivElement | null>(null);
+  const logIdRef = useRef(log.id);
   const displayLog = hydratedLog ?? log;
+  const useChunkedBody = hydratedLog === null && shouldUseChunkedBodyLoading(log);
+  const requestPreviewBody = bodyPreviewTextForView(useChunkedBody, requestPreview);
+  const responsePreviewBody = bodyPreviewTextForView(useChunkedBody, responsePreview);
+  const rawRequestBodyForView = displayLog.rawRequestBody ?? requestPreviewBody;
+  const responseTextForView = displayLog.responseText ?? responsePreviewBody;
+  const requestPreviewIsActive = displayLog.rawRequestBody === null && requestPreviewBody !== null;
+  const responsePreviewIsActive = displayLog.responseText === null && responsePreviewBody !== null;
+  const requestPreviewShouldParse =
+    !requestPreviewIsActive ||
+    (requestPreview.hasMore === false &&
+      bodyByteCount(requestPreview.totalBytes) <= CHUNKED_BODY_THRESHOLD_BYTES);
+  const responsePreviewShouldParse =
+    !responsePreviewIsActive ||
+    (responsePreview.hasMore === false &&
+      bodyByteCount(responsePreview.totalBytes) <= CHUNKED_BODY_THRESHOLD_BYTES);
   const resolvedFormat = resolveLogFormat(displayLog);
   const adapter = getLogFormatAdapter(resolvedFormat);
   const requestAnalysis = useMemo(
@@ -278,10 +416,16 @@ export const LogEntry = memo(function ({
     }
     return stripClaudeCodeBillingHeader(displayLog.rawRequestBody).body;
   }, [displayLog.rawRequestBody, resolvedFormat, strip]);
-  const displayedRequestBody = strippedRequestBody ?? displayLog.rawRequestBody;
-  const requestExpansion = useJsonBulkExpansion(displayedRequestBody);
-  const rawRequestExpansion = useJsonBulkExpansion(displayLog.rawRequestBody);
-  const responseExpansion = useJsonBulkExpansion(displayLog.responseText);
+  const displayedRequestBody = strippedRequestBody ?? rawRequestBodyForView;
+  const requestExpansion = useJsonBulkExpansion(
+    requestPreviewShouldParse ? displayedRequestBody : null,
+  );
+  const rawRequestExpansion = useJsonBulkExpansion(
+    requestPreviewShouldParse ? rawRequestBodyForView : null,
+  );
+  const responseExpansion = useJsonBulkExpansion(
+    responsePreviewShouldParse ? responseTextForView : null,
+  );
 
   // Headers are rendered as a flat list, so we copy them as pretty-printed JSON.
   // Only build the string when there's at least one entry — empty headers would
@@ -304,10 +448,10 @@ export const LogEntry = memo(function ({
   // One copy-feedback hook per JSON-bearing tab, so each tab can surface its
   // own Copy button in the header with independent "Copied!" feedback.
   const requestCopy = useCopyFeedback(displayedRequestBody);
-  const rawRequestCopy = useCopyFeedback(displayLog.rawRequestBody);
+  const rawRequestCopy = useCopyFeedback(rawRequestBodyForView);
   const headersCopy = useCopyFeedback(headersText);
   const rawHeadersCopy = useCopyFeedback(rawHeadersText);
-  const responseCopy = useCopyFeedback(displayLog.responseText);
+  const responseCopy = useCopyFeedback(responseTextForView);
 
   // Per-tab action bundles consumed by the header. The header renders the
   // entry whose key matches `activeTab`. Tabs without an entry (Context,
@@ -315,15 +459,17 @@ export const LogEntry = memo(function ({
   const tabActions: HeaderTabActions = useMemo(
     () => ({
       request: {
-        copyLabel: "Copy request body",
+        copyLabel: requestPreviewIsActive ? "Copy loaded request preview" : "Copy request body",
         copyText: displayedRequestBody,
         copyCopied: requestCopy.copied,
         onCopy: requestCopy.copy,
-        expansion: {
-          isExpanded: requestExpansion.isExpanded,
-          isPending: requestExpansion.isPending,
-          onToggle: requestExpansion.toggle,
-        },
+        expansion: requestPreviewShouldParse
+          ? {
+              isExpanded: requestExpansion.isExpanded,
+              isPending: requestExpansion.isPending,
+              onToggle: requestExpansion.toggle,
+            }
+          : null,
         // "Diff with Raw" only makes sense when there's a raw body to compare
         // against (Anthropic + strip pipeline produces one). "Diff with
         // Previous" only exists when the parent wired up the compare drawer.
@@ -343,15 +489,17 @@ export const LogEntry = memo(function ({
               },
       },
       "raw-request": {
-        copyLabel: "Copy raw request",
-        copyText: displayLog.rawRequestBody,
+        copyLabel: requestPreviewIsActive ? "Copy loaded raw request preview" : "Copy raw request",
+        copyText: rawRequestBodyForView,
         copyCopied: rawRequestCopy.copied,
         onCopy: rawRequestCopy.copy,
-        expansion: {
-          isExpanded: rawRequestExpansion.isExpanded,
-          isPending: rawRequestExpansion.isPending,
-          onToggle: rawRequestExpansion.toggle,
-        },
+        expansion: requestPreviewShouldParse
+          ? {
+              isExpanded: rawRequestExpansion.isExpanded,
+              isPending: rawRequestExpansion.isPending,
+              onToggle: rawRequestExpansion.toggle,
+            }
+          : null,
       },
       headers: {
         copyLabel: "Copy headers",
@@ -369,24 +517,29 @@ export const LogEntry = memo(function ({
         expansion: null,
       },
       raw: {
-        copyLabel: "Copy response",
-        copyText: displayLog.responseText,
+        copyLabel: responsePreviewIsActive ? "Copy loaded response preview" : "Copy response",
+        copyText: responseTextForView,
         copyCopied: responseCopy.copied,
         onCopy: responseCopy.copy,
-        expansion: {
-          isExpanded: responseExpansion.isExpanded,
-          isPending: responseExpansion.isPending,
-          onToggle: responseExpansion.toggle,
-        },
+        expansion: responsePreviewShouldParse
+          ? {
+              isExpanded: responseExpansion.isExpanded,
+              isPending: responseExpansion.isPending,
+              onToggle: responseExpansion.toggle,
+            }
+          : null,
       },
     }),
     [
       displayedRequestBody,
+      requestPreviewIsActive,
+      requestPreviewShouldParse,
       requestCopy,
       requestExpansion,
       requestDiff,
       displayLog,
       displayLog.rawRequestBody,
+      rawRequestBodyForView,
       rawRequestCopy,
       rawRequestExpansion,
       headersText,
@@ -394,6 +547,9 @@ export const LogEntry = memo(function ({
       rawHeadersText,
       rawHeadersCopy,
       displayLog.responseText,
+      responsePreviewIsActive,
+      responsePreviewShouldParse,
+      responseTextForView,
       responseCopy,
       responseExpansion,
       resolvedFormat,
@@ -425,6 +581,48 @@ export const LogEntry = memo(function ({
       if (activeTab !== "request") setActiveTab("request");
     },
   });
+  const loadBodyChunk = useCallback(
+    (part: LogBodyPart, offset: number) => {
+      const setPreview = part === "request" ? setRequestPreview : setResponsePreview;
+      setPreview((current) => ({
+        ...current,
+        status: "loading",
+        error: null,
+      }));
+
+      const params = new URLSearchParams({
+        part,
+        offset: String(offset),
+        limit: String(BODY_CHUNK_BYTES),
+      });
+
+      void fetchJsonWithTimeout(
+        `/api/logs/${String(log.id)}/body?${params.toString()}`,
+        LogBodyChunkSchema,
+        BODY_CHUNK_TIMEOUT_MS,
+      )
+        .then((chunk) => {
+          if (logIdRef.current !== log.id) return;
+          setPreview((current) => ({
+            status: "success",
+            text: chunk.offset === 0 ? chunk.text : `${current.text}${chunk.text}`,
+            offset: chunk.nextOffset ?? chunk.totalBytes,
+            totalBytes: chunk.totalBytes,
+            hasMore: chunk.hasMore,
+            error: null,
+          }));
+        })
+        .catch((error: unknown) => {
+          if (logIdRef.current !== log.id) return;
+          setPreview((current) => ({
+            ...current,
+            status: "failed",
+            error: bodyPreviewErrorMessage(error),
+          }));
+        });
+    },
+    [log.id],
+  );
 
   const handleToggleExpanded = useCallback(() => {
     const nextExpanded = !expanded;
@@ -435,9 +633,12 @@ export const LogEntry = memo(function ({
   }, [anatomySegments, expanded]);
 
   useEffect(() => {
+    logIdRef.current = log.id;
     setHydratedLog(null);
     setBodyHydrationState("idle");
-  }, [log.id]);
+    setRequestPreview(createEmptyBodyPreviewState(log.rawRequestBodyBytes ?? null));
+    setResponsePreview(createEmptyBodyPreviewState(log.responseTextBytes ?? null));
+  }, [log.id, log.rawRequestBodyBytes, log.responseTextBytes]);
 
   useEffect(() => {
     if (!expanded) return;
@@ -446,7 +647,11 @@ export const LogEntry = memo(function ({
 
     let cancelled = false;
     setBodyHydrationState("loading");
-    void fetchJson(`/api/logs/${String(log.id)}`, CapturedLogSchema)
+    void fetchJsonWithTimeout(
+      `/api/logs/${String(log.id)}`,
+      CapturedLogSchema,
+      FULL_LOG_HYDRATION_TIMEOUT_MS,
+    )
       .then((fullLog) => {
         if (cancelled) return;
         setHydratedLog(fullLog);
@@ -460,7 +665,31 @@ export const LogEntry = memo(function ({
     return () => {
       cancelled = true;
     };
-  }, [bodyHydrationState, expanded, hydratedLog, log.bodyContentMode, log.id]);
+  }, [
+    bodyHydrationState,
+    expanded,
+    hydratedLog,
+    log.bodyContentMode,
+    log.id,
+    log.rawRequestBodyBytes,
+    log.responseTextBytes,
+  ]);
+
+  useEffect(() => {
+    if (!expanded) return;
+    if (!useChunkedBody) return;
+    if (requestPreview.status !== "idle") return;
+    if (activeTab !== "request" && activeTab !== "raw-request" && activeTab !== "anatomy") return;
+    loadBodyChunk("request", 0);
+  }, [activeTab, expanded, loadBodyChunk, requestPreview.status, useChunkedBody]);
+
+  useEffect(() => {
+    if (!expanded) return;
+    if (!useChunkedBody) return;
+    if (responsePreview.status !== "idle") return;
+    if (activeTab !== "parsed" && activeTab !== "raw") return;
+    loadBodyChunk("response", 0);
+  }, [activeTab, expanded, loadBodyChunk, responsePreview.status, useChunkedBody]);
 
   useEffect(() => {
     const handleLogFocusRequest = (event: Event): void => {
@@ -555,8 +784,18 @@ export const LogEntry = memo(function ({
                 <TabsContent value="raw-request">
                   {activeTab === "raw-request" && (
                     <ExpandedPanel>
-                      {displayLog.rawRequestBody === null ? (
-                        <EmptyState>No request body</EmptyState>
+                      {useChunkedBody && (
+                        <BodyPreviewNotice
+                          label="Request"
+                          state={requestPreview}
+                          expectedBytes={log.rawRequestBodyBytes ?? null}
+                          onLoadMore={() => loadBodyChunk("request", requestPreview.offset)}
+                        />
+                      )}
+                      {rawRequestBodyForView === null ? (
+                        <EmptyState>
+                          {useChunkedBody ? "Request preview is loading" : "No request body"}
+                        </EmptyState>
                       ) : rawRequestExpansion.parsedData !== null ? (
                         <Suspense fallback={<TabFallback />}>
                           <LazyJsonViewer
@@ -566,7 +805,7 @@ export const LogEntry = memo(function ({
                           />
                         </Suspense>
                       ) : (
-                        <RawTextBlock>{displayLog.rawRequestBody}</RawTextBlock>
+                        <RawTextBlock>{rawRequestBodyForView}</RawTextBlock>
                       )}
                     </ExpandedPanel>
                   )}
@@ -587,6 +826,14 @@ export const LogEntry = memo(function ({
                         still available.
                       </NoticeBlock>
                     )}
+                    {useChunkedBody && (
+                      <BodyPreviewNotice
+                        label="Request"
+                        state={requestPreview}
+                        expectedBytes={log.rawRequestBodyBytes ?? null}
+                        onLoadMore={() => loadBodyChunk("request", requestPreview.offset)}
+                      />
+                    )}
                     {warnings.length > 0 && (
                       <NoticeBlock tone="warning">
                         <div className="flex items-center gap-2 font-semibold text-amber-300">
@@ -616,7 +863,9 @@ export const LogEntry = memo(function ({
                     ) : (
                       <div ref={requestJsonRef}>
                         {displayedRequestBody === null ? (
-                          <EmptyState>No request body</EmptyState>
+                          <EmptyState>
+                            {useChunkedBody ? "Request preview is loading" : "No request body"}
+                          </EmptyState>
                         ) : requestExpansion.parsedData !== null ? (
                           <Suspense fallback={<TabFallback />}>
                             <LazyJsonViewer
@@ -705,22 +954,34 @@ export const LogEntry = memo(function ({
               <TabsContent value="raw">
                 {activeTab === "raw" && (
                   <ExpandedPanel className="space-y-3">
+                    {useChunkedBody && (
+                      <BodyPreviewNotice
+                        label="Response"
+                        state={responsePreview}
+                        expectedBytes={log.responseTextBytes ?? null}
+                        onLoadMore={() => loadBodyChunk("response", responsePreview.offset)}
+                      />
+                    )}
                     {displayLog.error !== undefined && displayLog.error !== null && (
                       <NoticeBlock tone="danger" title="SSE Error">
                         <span className="font-mono">{displayLog.error}</span>
                       </NoticeBlock>
                     )}
-                    {displayLog.responseText !== null ? (
+                    {responseTextForView !== null && responsePreviewShouldParse ? (
                       <Suspense fallback={<TabFallback />}>
                         <LazyJsonViewerFromString
-                          text={displayLog.responseText}
+                          text={responseTextForView}
                           defaultExpandDepth={0}
                           bulkDepth={responseExpansion.bulkDepth}
                           bulkRevision={responseExpansion.bulkRevision}
                         />
                       </Suspense>
+                    ) : responseTextForView !== null ? (
+                      <RawTextBlock>{responseTextForView}</RawTextBlock>
                     ) : (
-                      <EmptyState>No response</EmptyState>
+                      <EmptyState>
+                        {useChunkedBody ? "Response preview is loading" : "No response"}
+                      </EmptyState>
                     )}
                     {displayLog.streaming === true && (
                       <Suspense fallback={<TabFallback />}>
@@ -737,19 +998,31 @@ export const LogEntry = memo(function ({
               <TabsContent value="parsed">
                 {activeTab === "parsed" && (
                   <ExpandedPanel>
-                    <Suspense fallback={<TabFallback />}>
-                      <LazyResponseView
-                        responseText={displayLog.responseText}
-                        responseStatus={displayLog.responseStatus}
-                        streaming={displayLog.streaming}
-                        inputTokens={displayLog.inputTokens}
-                        outputTokens={displayLog.outputTokens}
-                        cacheCreationInputTokens={displayLog.cacheCreationInputTokens}
-                        cacheReadInputTokens={displayLog.cacheReadInputTokens}
-                        apiFormat={resolvedFormat}
-                        error={displayLog.error}
+                    {useChunkedBody && (
+                      <BodyPreviewNotice
+                        label="Response"
+                        state={responsePreview}
+                        expectedBytes={log.responseTextBytes ?? null}
+                        onLoadMore={() => loadBodyChunk("response", responsePreview.offset)}
                       />
-                    </Suspense>
+                    )}
+                    {responsePreviewIsActive && !responsePreviewShouldParse ? (
+                      <RawTextBlock>{responseTextForView}</RawTextBlock>
+                    ) : (
+                      <Suspense fallback={<TabFallback />}>
+                        <LazyResponseView
+                          responseText={responseTextForView}
+                          responseStatus={displayLog.responseStatus}
+                          streaming={displayLog.streaming}
+                          inputTokens={displayLog.inputTokens}
+                          outputTokens={displayLog.outputTokens}
+                          cacheCreationInputTokens={displayLog.cacheCreationInputTokens}
+                          cacheReadInputTokens={displayLog.cacheReadInputTokens}
+                          apiFormat={resolvedFormat}
+                          error={displayLog.error}
+                        />
+                      </Suspense>
+                    )}
                   </ExpandedPanel>
                 )}
               </TabsContent>

package/src/components/ui/dialog.tsx

@@ -125,5 +125,6 @@ export {
   DialogTrigger,
   DialogContent,
   DialogHeader,
+  DialogDescription,
   DialogTitle,
 };

package/src/contracts/index.ts

@@ -1,8 +1,21 @@
 export { JsonValueSchema, trustAsJsonValue } from "./json";
 export type { JsonValue } from "./json";
 
-export { CapturedLogSchema, StreamingChunkSchema } from "./log";
-export type { ApiFormat, CapturedLog, RequestFormat, StreamingChunk, TokenUsage } from "./log";
+export {
+  CapturedLogSchema,
+  LogBodyChunkSchema,
+  LogBodyPartSchema,
+  StreamingChunkSchema,
+} from "./log";
+export type {
+  ApiFormat,
+  CapturedLog,
+  LogBodyChunk,
+  LogBodyPart,
+  RequestFormat,
+  StreamingChunk,
+  TokenUsage,
+} from "./log";
 
 export {
   AnthropicRequestSchema,

package/src/contracts/log.ts

@@ -21,6 +21,24 @@ const StreamingChunksArraySchema = z.object({
   truncated: z.boolean().optional().default(false),
 });
 
+export const LogBodyPartSchema = z.enum(["request", "response"]);
+export type LogBodyPart = z.infer<typeof LogBodyPartSchema>;
+
+export const LogBodyChunkSchema = z.object({
+  logId: z.number().int().positive(),
+  part: LogBodyPartSchema,
+  text: z.string(),
+  offset: z.number().int().nonnegative(),
+  limit: z.number().int().positive(),
+  totalBytes: z.number().int().nonnegative(),
+  textBytes: z.number().int().nonnegative(),
+  nextOffset: z.number().int().nonnegative().nullable(),
+  hasMore: z.boolean(),
+  contentMode: z.enum(["empty", "partial", "full"]),
+});
+
+export type LogBodyChunk = z.infer<typeof LogBodyChunkSchema>;
+
 export const CapturedLogSchema = z.object({
   id: z.number(),
   timestamp: z.string(),