fix(parser): render codex function calls as informative tool blocks

Author: wesm

frontend/src/lib/utils/content-parser.test.ts

@@ -108,6 +108,15 @@ describe("parseContent", () => {
     });
   });
 
+  it("parses codex tool markers and normalizes label", () => {
+    const segments = parseContent("[exec_command]\n$ rg --files");
+    expect(segments[0]).toEqual({
+      type: "tool",
+      content: "$ rg --files",
+      label: "Bash",
+    });
+  });
+
   it("drops overlapping matches", () => {
     const text = "[Thinking]\nI think\n[Bash]\necho ok";
     const segments = parseContent(text);
@@ -173,4 +182,12 @@ describe("isToolOnly", () => {
     });
     expect(isToolOnly(msg)).toBe(true);
   });
+
+  it("treats codex markers as tool-only content", () => {
+    const msg = makeMsg({
+      has_tool_use: true,
+      content: "[exec_command]\n$ pwd",
+    });
+    expect(isToolOnly(msg)).toBe(true);
+  });
 });

frontend/src/lib/utils/content-parser.ts

@@ -20,7 +20,17 @@ const THINKING_RE =
 const TOOL_NAMES =
   "Tool|Read|Write|Edit|Bash|Glob|Grep|Task|" +
   "Question|Todo List|Entering Plan Mode|" +
-  "Exiting Plan Mode";
+  "Exiting Plan Mode|exec_command|shell_command|" +
+  "write_stdin|apply_patch|shell|parallel|view_image|" +
+  "request_user_input|update_plan";
+
+const TOOL_ALIASES: Record<string, string> = {
+  exec_command: "Bash",
+  shell_command: "Bash",
+  write_stdin: "Bash",
+  shell: "Bash",
+  apply_patch: "Edit",
+};
 
 const TOOL_RE = new RegExp(
   `\\[(${TOOL_NAMES})([^\\]]*)\\]([\\s\\S]*?)(?=\\n\\[|\\n\\n|$)`,
@@ -76,9 +86,10 @@ function extractMatches(text: string): Match[] {
   for (const m of text.matchAll(TOOL_RE)) {
     const toolName = m[1] ?? "";
     const toolArgs = (m[2] ?? "").trim();
+    const displayName = TOOL_ALIASES[toolName] ?? toolName;
     const label = toolArgs
-      ? `${toolName} ${toolArgs}`
-      : toolName;
+      ? `${displayName} ${toolArgs}`
+      : displayName;
     matches.push({
       start: m.index!,
       end: m.index! + m[0].length,

internal/parser/codex.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strconv"
 	"strings"
 	"time"
 
@@ -156,11 +157,307 @@ func (b *codexSessionBuilder) handleFunctionCall(
 func formatCodexFunctionCall(
 	name string, payload gjson.Result,
 ) string {
-	summary := payload.Get("summary").Str
-	if summary != "" {
-		return fmt.Sprintf("[%s: %s]", name, summary)
+	summary := sanitizeToolLabel(payload.Get("summary").Str)
+	args, rawArgs := parseCodexFunctionArgs(payload)
+
+	switch name {
+	case "exec_command", "shell_command", "shell":
+		return formatCodexBashCall(summary, args, rawArgs)
+	case "write_stdin":
+		return formatCodexWriteStdinCall(summary, args, rawArgs)
+	case "apply_patch":
+		return formatCodexApplyPatchCall(summary, args, rawArgs)
 	}
-	return fmt.Sprintf("[%s]", name)
+
+	category := NormalizeToolCategory(name)
+	if category == "Other" {
+		header := formatToolHeader("Tool", name)
+		if summary != "" {
+			return header + "\n" + summary
+		}
+		if preview := codexArgPreview(args, rawArgs); preview != "" {
+			return header + "\n" + preview
+		}
+		return header
+	}
+
+	detail := firstNonEmpty(summary,
+		codexCategoryDetail(category, args))
+	header := formatToolHeader(category, detail)
+	if preview := codexArgPreview(args, rawArgs); preview != "" {
+		return header + "\n" + preview
+	}
+	return header
+}
+
+func parseCodexFunctionArgs(
+	payload gjson.Result,
+) (gjson.Result, string) {
+	for _, key := range []string{"arguments", "input"} {
+		arg := payload.Get(key)
+		if !arg.Exists() {
+			continue
+		}
+
+		switch arg.Type {
+		case gjson.String:
+			s := strings.TrimSpace(arg.Str)
+			if s == "" {
+				continue
+			}
+			if gjson.Valid(s) {
+				return gjson.Parse(s), ""
+			}
+			return gjson.Result{}, s
+		default:
+			if arg.IsObject() || arg.IsArray() {
+				return arg, ""
+			}
+			raw := strings.TrimSpace(arg.Raw)
+			if raw == "" {
+				continue
+			}
+			if gjson.Valid(raw) {
+				return gjson.Parse(raw), ""
+			}
+			return gjson.Result{}, raw
+		}
+	}
+	return gjson.Result{}, ""
+}
+
+func formatCodexBashCall(
+	summary string, args gjson.Result, rawArgs string,
+) string {
+	cmd := codexArgValue(args, "cmd", "command")
+	if cmd == "" && rawArgs != "" && !gjson.Valid(rawArgs) {
+		cmd = rawArgs
+	}
+	if cmd == "" && args.Type == gjson.String {
+		cmd = strings.TrimSpace(args.Str)
+	}
+
+	header := formatToolHeader("Bash", summary)
+	if cmd != "" {
+		return header + "\n$ " + cmd
+	}
+	if preview := codexArgPreview(args, rawArgs); preview != "" {
+		return header + "\n" + preview
+	}
+	return header
+}
+
+func formatCodexWriteStdinCall(
+	summary string, args gjson.Result, rawArgs string,
+) string {
+	if summary == "" {
+		if sid := codexArgValue(args, "session_id"); sid != "" {
+			summary = "stdin -> " + sid
+		} else {
+			summary = "stdin"
+		}
+	}
+
+	header := formatToolHeader("Bash", summary)
+	chars := codexArgString(args, "chars")
+	if chars != "" {
+		quoted := strings.Trim(
+			strconv.QuoteToASCII(chars), "\"",
+		)
+		return header + "\n" + truncate(quoted, 220)
+	}
+
+	if preview := codexArgPreview(args, rawArgs); preview != "" {
+		return header + "\n" + preview
+	}
+	return header
+}
+
+func formatCodexApplyPatchCall(
+	summary string, args gjson.Result, rawArgs string,
+) string {
+	patch := codexArgString(args, "patch")
+	if patch == "" && strings.Contains(rawArgs, "*** Begin Patch") {
+		patch = rawArgs
+	}
+
+	files := extractPatchedFiles(patch)
+	if summary == "" {
+		summary = summarizePatchedFiles(files)
+	}
+
+	header := formatToolHeader("Edit", summary)
+	if len(files) > 1 {
+		limit := min(len(files), 6)
+		body := strings.Join(files[:limit], "\n")
+		if len(files) > limit {
+			body += fmt.Sprintf("\n+%d more files", len(files)-limit)
+		}
+		return header + "\n" + body
+	}
+	if preview := codexArgPreview(args, rawArgs); preview != "" &&
+		len(files) == 0 {
+		return header + "\n" + preview
+	}
+	return header
+}
+
+func extractPatchedFiles(patch string) []string {
+	if patch == "" {
+		return nil
+	}
+
+	var files []string
+	seen := make(map[string]struct{})
+	lines := strings.Split(patch, "\n")
+	for _, line := range lines {
+		for _, prefix := range []string{
+			"*** Add File: ",
+			"*** Update File: ",
+			"*** Delete File: ",
+			"*** Move to: ",
+		} {
+			if !strings.HasPrefix(line, prefix) {
+				continue
+			}
+			file := strings.TrimSpace(
+				strings.TrimPrefix(line, prefix),
+			)
+			if file == "" {
+				continue
+			}
+			if _, ok := seen[file]; ok {
+				continue
+			}
+			seen[file] = struct{}{}
+			files = append(files, file)
+			break
+		}
+	}
+	return files
+}
+
+func summarizePatchedFiles(files []string) string {
+	switch len(files) {
+	case 0:
+		return ""
+	case 1:
+		return files[0]
+	default:
+		return fmt.Sprintf(
+			"%s (+%d more)",
+			files[0], len(files)-1,
+		)
+	}
+}
+
+func codexCategoryDetail(
+	category string, args gjson.Result,
+) string {
+	switch category {
+	case "Read", "Write", "Edit":
+		return codexArgValue(args, "file_path", "path")
+	case "Grep":
+		return codexArgValue(args, "pattern")
+	case "Glob":
+		pattern := codexArgValue(args, "pattern")
+		path := codexArgValue(args, "path")
+		if pattern != "" && path != "" {
+			return fmt.Sprintf("%s in %s", pattern, path)
+		}
+		return firstNonEmpty(pattern, path)
+	case "Task":
+		desc := codexArgValue(args, "description")
+		agent := codexArgValue(args, "subagent_type")
+		if desc != "" && agent != "" {
+			return fmt.Sprintf("%s (%s)", desc, agent)
+		}
+		return firstNonEmpty(desc, agent)
+	default:
+		return ""
+	}
+}
+
+func codexArgString(
+	args gjson.Result, path string,
+) string {
+	v := args.Get(path)
+	if !v.Exists() {
+		return ""
+	}
+	if v.Type == gjson.String {
+		return v.Str
+	}
+	raw := strings.TrimSpace(v.Raw)
+	if raw == "" || raw == "null" {
+		return ""
+	}
+	return raw
+}
+
+func codexArgValue(
+	args gjson.Result, paths ...string,
+) string {
+	for _, path := range paths {
+		v := strings.TrimSpace(codexArgString(args, path))
+		if v != "" {
+			return v
+		}
+	}
+	return ""
+}
+
+func codexArgPreview(
+	args gjson.Result, rawArgs string,
+) string {
+	if rawArgs != "" {
+		flat := strings.Join(
+			strings.Fields(rawArgs), " ",
+		)
+		return truncate(flat, 220)
+	}
+	if args.Exists() {
+		flat := strings.Join(
+			strings.Fields(args.Raw), " ",
+		)
+		if flat != "" {
+			return truncate(flat, 220)
+		}
+	}
+	return ""
+}
+
+func formatToolHeader(
+	label, detail string,
+) string {
+	label = sanitizeToolLabel(label)
+	if label == "" {
+		label = "Tool"
+	}
+	detail = sanitizeToolLabel(detail)
+	if detail != "" {
+		return fmt.Sprintf("[%s: %s]", label, detail)
+	}
+	return fmt.Sprintf("[%s]", label)
+}
+
+func sanitizeToolLabel(s string) string {
+	s = strings.TrimSpace(s)
+	if s == "" {
+		return ""
+	}
+	s = strings.ReplaceAll(s, "]", ")")
+	return strings.Join(strings.Fields(s), " ")
+}
+
+func firstNonEmpty(vals ...string) string {
+	for _, v := range vals {
+		v = strings.TrimSpace(v)
+		if v != "" {
+			return v
+		}
+	}
+	return ""
 }
 
 // extractCodexContent joins all text blocks from a Codex