fix: render all files in multi-file Codex edits

Codex bundles multiple file changes into a single tool_call message via
structuredPatch, but the entire rendering pipeline only processed the
first entry. Now all patch entries are iterated in EditContent,
WriteContent, turn-changes, file-access, and tool-formatting.

Extract shared patch-utils module (StructuredPatchEntry type,
getStructuredPatches, getPatchPath, filterValidPatches) to eliminate
duplicate extraction logic across 5 consumer files. Remove duplicate
firstDefinedString from turn-changes.ts, add React.memo to
PatchEntryDiff/PatchEntryWrite components, and replace untyped
Record<string, unknown> with the proper StructuredPatchEntry interface.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: OpenSource03

src/components/lib/tool-formatting.ts

@@ -1,6 +1,7 @@
 import type { UIMessage, SubagentToolStep } from "@/types";
 import { getMcpCompactSummary } from "@/components/McpToolContent";
 import { getTodoItems } from "@/lib/todo-utils";
+import { getStructuredPatches } from "@/lib/patch-utils";
 
 // ── Compact summary for collapsed tool line ──
 
@@ -62,6 +63,11 @@ export function formatCompactSummary(message: UIMessage): string {
   }
 
   if (input.command) return String(input.command).split("\n")[0];
+  // Multi-file Codex edits: show file count instead of single filename
+  const patches = getStructuredPatches(result);
+  if (input.file_path && patches.length > 1) {
+    return `${patches.length} files`;
+  }
   if (input.file_path) return String(input.file_path).split("/").pop() ?? "";
   if (filePathFromResult) return filePathFromResult.split("/").pop() ?? filePathFromResult;
   if (input.pattern) {

src/components/tool-renderers/EditContent.tsx

@@ -1,19 +1,67 @@
+import { memo } from "react";
 import type { UIMessage } from "@/types";
 import { parseUnifiedDiffFromUnknown } from "@/lib/unified-diff";
 import { DiffViewer } from "@/components/DiffViewer";
 import { UnifiedPatchViewer } from "@/components/UnifiedPatchViewer";
 import { firstDefinedString } from "@/components/lib/tool-formatting";
+import { getStructuredPatches, getPatchPath, filterValidPatches, type StructuredPatchEntry } from "@/lib/patch-utils";
 import { GenericContent } from "./GenericContent";
 
+// ── Multi-file rendering (Codex fileChange with N > 1 changes) ──
+
+/** Render a single patch entry from a structuredPatch array. */
+const PatchEntryDiff = memo(function PatchEntryDiff({ patch }: { patch: StructuredPatchEntry }) {
+  const filePath = getPatchPath(patch);
+  const diffText = patch.diff ?? "";
+  const parsedDiff = diffText ? parseUnifiedDiffFromUnknown(diffText) : null;
+  const oldStr = firstDefinedString(patch.oldString, parsedDiff?.oldString);
+  const newStr = firstDefinedString(patch.newString, parsedDiff?.newString);
+
+  if (oldStr || newStr) {
+    return (
+      <DiffViewer
+        oldString={oldStr}
+        newString={newStr}
+        filePath={filePath}
+        unifiedDiff={hasUnifiedDiffMarkers(diffText) ? diffText : undefined}
+      />
+    );
+  }
+
+  if (diffText) {
+    return <UnifiedPatchViewer diffText={diffText} filePath={filePath} />;
+  }
+
+  return null;
+});
+
+// ── Main component ──
+
 export function EditContent({ message }: { message: UIMessage }) {
-  const structuredPatch = Array.isArray(message.toolResult?.structuredPatch)
-    ? (message.toolResult.structuredPatch as Array<Record<string, unknown>>)
-    : [];
+  const structuredPatch = getStructuredPatches(message.toolResult);
+
+  // Multi-file Codex fileChange: render each file's diff separately
+  if (structuredPatch.length > 1) {
+    const validPatches = filterValidPatches(structuredPatch);
+    if (validPatches.length === 0) return <GenericContent message={message} />;
+    return (
+      <div className="space-y-2">
+        {validPatches.map((patch, i) => (
+          <PatchEntryDiff
+            key={`${getPatchPath(patch)}-${i}`}
+            patch={patch}
+          />
+        ))}
+      </div>
+    );
+  }
+
+  // Single-file: existing logic with full fallback chain
+  // (Claude engine, ACP engine, single-file Codex edits)
   const matchingPatch =
     structuredPatch.find((entry) => {
-      const entryPath = entry.filePath ?? entry.path;
-      return typeof entryPath === "string"
-        && entryPath
+      const entryPath = getPatchPath(entry);
+      return entryPath
         && entryPath === String(message.toolInput?.file_path ?? message.toolResult?.filePath ?? "");
     }) ?? structuredPatch[0];
   const resultContent = typeof message.toolResult?.content === "string"
@@ -22,12 +70,12 @@ export function EditContent({ message }: { message: UIMessage }) {
   const detailedContent = typeof message.toolResult?.detailedContent === "string"
     ? message.toolResult.detailedContent
     : "";
-  const patchDiffText = typeof matchingPatch?.diff === "string" ? matchingPatch.diff : "";
+  const patchDiffText = matchingPatch?.diff ?? "";
   const candidateDiffText = selectUnifiedDiffText(patchDiffText, detailedContent, resultContent);
   const filePath = String(
     message.toolInput?.file_path
       ?? message.toolResult?.filePath
-      ?? (typeof matchingPatch?.filePath === "string" ? matchingPatch.filePath : "")
+      ?? matchingPatch?.filePath
       ?? extractFilePathFromDiff(candidateDiffText)
       ?? "",
   );
@@ -38,15 +86,15 @@ export function EditContent({ message }: { message: UIMessage }) {
   const unifiedDiffText = candidateDiffText;
   // Prefer parsed/structured patch text first; toolInput can be a lossy representation.
   const oldStr = firstDefinedString(
-    typeof matchingPatch?.oldString === "string" ? matchingPatch.oldString : undefined,
+    matchingPatch?.oldString,
     parsedStructuredDiff?.oldString,
     parsedDiff?.oldString,
     parsedDetailedDiff?.oldString,
     message.toolResult?.oldString,
     message.toolInput?.old_string,
   );
   const newStr = firstDefinedString(
-    typeof matchingPatch?.newString === "string" ? matchingPatch.newString : undefined,
+    matchingPatch?.newString,
     parsedStructuredDiff?.newString,
     parsedDiff?.newString,
     parsedDetailedDiff?.newString,

src/components/tool-renderers/WriteContent.tsx

@@ -1,3 +1,4 @@
+import { memo } from "react";
 import { Prism as SyntaxHighlighter } from "react-syntax-highlighter";
 import { oneDark } from "react-syntax-highlighter/dist/esm/styles/prism";
 import { oneLight } from "react-syntax-highlighter/dist/esm/styles/prism";
@@ -7,6 +8,7 @@ import { useResolvedThemeClass } from "@/hooks/useResolvedThemeClass";
 import { parseUnifiedDiff } from "@/lib/unified-diff";
 import { UnifiedPatchViewer } from "@/components/UnifiedPatchViewer";
 import { OpenInEditorButton } from "@/components/OpenInEditorButton";
+import { getStructuredPatches, getPatchPath, filterValidPatches, type StructuredPatchEntry } from "@/lib/patch-utils";
 import { GenericContent } from "./GenericContent";
 
 // ── Stable style constants (avoid re-creating on every render) ──
@@ -27,20 +29,55 @@ const WRITE_LINE_NUMBER_STYLE: React.CSSProperties = {
   paddingRight: "1em",
 };
 
+// ── Multi-file rendering (Codex fileChange where all changes are "add") ──
+
+const PatchEntryWrite = memo(function PatchEntryWrite({ patch }: { patch: StructuredPatchEntry }) {
+  const filePath = getPatchPath(patch);
+
+  // Codex reports new-file diffs in unified format — use the patch viewer
+  if (patch.diff) {
+    return <UnifiedPatchViewer diffText={patch.diff} filePath={filePath} />;
+  }
+
+  // Fallback: show newString content if available
+  if (patch.newString) {
+    return <UnifiedPatchViewer diffText={patch.newString} filePath={filePath} />;
+  }
+
+  return null;
+});
+
+// ── Main component ──
+
 export function WriteContent({ message }: { message: UIMessage }) {
   const resolvedTheme = useResolvedThemeClass();
   const syntaxStyle = resolvedTheme === "dark" ? oneDark : oneLight;
+  const structuredPatch = getStructuredPatches(message.toolResult);
+
+  // Multi-file Codex fileChange: render each new file separately
+  if (structuredPatch.length > 1) {
+    const validPatches = filterValidPatches(structuredPatch);
+    if (validPatches.length === 0) return <GenericContent message={message} />;
+    return (
+      <div className="space-y-2">
+        {validPatches.map((patch, i) => (
+          <PatchEntryWrite
+            key={`${getPatchPath(patch)}-${i}`}
+            patch={patch}
+          />
+        ))}
+      </div>
+    );
+  }
+
+  // Single-file: existing logic
   const filePath = String(
     message.toolInput?.file_path
       ?? message.toolResult?.filePath
       ?? "",
   );
   // Codex "wrote" may have a structuredPatch with a unified diff
-  const structuredPatch = Array.isArray(message.toolResult?.structuredPatch)
-    ? (message.toolResult.structuredPatch as Array<Record<string, unknown>>)
-    : [];
-  const patchDiff = structuredPatch.length > 0
-    && typeof structuredPatch[0].diff === "string"
+  const patchDiff = structuredPatch.length > 0 && structuredPatch[0].diff
     ? structuredPatch[0].diff
     : null;
   // Use UnifiedPatchViewer when the patch is a proper unified diff

src/lib/file-access.ts

@@ -5,6 +5,7 @@
 
 import { Eye, Pencil, Plus } from "lucide-react";
 import type { UIMessage } from "@/types";
+import { getStructuredPatches, getPatchPath } from "@/lib/patch-utils";
 
 export type AccessType = "read" | "modified" | "created";
 
@@ -206,6 +207,16 @@ export function extractFiles(messages: UIMessage[], cwd?: string, includeClaudeM
         const totalLines = msg.toolResult?.file?.totalLines;
         recordAccess(filePath, access, msg.timestamp, range, totalLines);
       }
+      // Multi-file Codex edits: record additional file paths from structuredPatch
+      if (access) {
+        for (const patch of getStructuredPatches(msg.toolResult)) {
+          const patchPath = getPatchPath(patch);
+          if (patchPath && patchPath !== filePath) {
+            const patchAccess: AccessType = patch.kind === "add" ? "created" : access;
+            recordAccess(patchPath, patchAccess, msg.timestamp, null);
+          }
+        }
+      }
     }
 
     // Subagent steps — skip failed ones

src/lib/patch-utils.ts

@@ -0,0 +1,45 @@
+/**
+ * Shared utilities for working with structuredPatch entries.
+ *
+ * Codex bundles multiple file changes into a single tool_call message.
+ * The per-file changes are stored in `toolResult.structuredPatch`.
+ * These helpers provide typed access and deduplication across the
+ * rendering pipeline (renderers, summaries, file tracking, formatting).
+ */
+
+import type { UIMessage } from "@/types";
+
+// ── Types ──
+
+/** A single entry from toolResult.structuredPatch. */
+export interface StructuredPatchEntry {
+  filePath?: string;
+  path?: string; // Legacy / ACP fallback for filePath
+  kind?: string; // "add" | "delete" | "update"
+  diff?: string;
+  oldString?: string;
+  newString?: string;
+}
+
+// ── Extraction ──
+
+/** Extract the structuredPatch array from a tool result, safely typed. */
+export function getStructuredPatches(
+  toolResult: UIMessage["toolResult"],
+): StructuredPatchEntry[] {
+  return Array.isArray(toolResult?.structuredPatch)
+    ? (toolResult.structuredPatch as StructuredPatchEntry[])
+    : [];
+}
+
+/** Get the file path from a patch entry (filePath preferred, path as fallback). */
+export function getPatchPath(patch: StructuredPatchEntry): string {
+  return patch.filePath || patch.path || "";
+}
+
+/** Filter patches to only those with a non-empty file path. */
+export function filterValidPatches(
+  patches: StructuredPatchEntry[],
+): StructuredPatchEntry[] {
+  return patches.filter((p) => getPatchPath(p) !== "");
+}