Summary

• Problem: failed tool results in chat could look like successful tool output with a checkmark.
• Solution: propagate explicit isError / is_error flags into tool cards and add bounded fallback detection for common error payloads.
• What changed: tool cards, standalone tool-result summaries, sidebar content, and expanded output labels now render failed tool results with error styling and copy.
• What did NOT change (scope boundary): no agent execution, gateway protocol, tool runtime, or NemoClaw code paths were changed.

Motivation

• [NemoClaw][macOS][CLI&UX] OpenClaw chat UI shows ✓ Completed on tool calls that returned error / "Tool not found" NVIDIA/NemoClaw#2621 showed that an OpenClaw UI surface could display a tool failure as normal output, which hid the real failure mode from users during triage.
• This should be fixed in OpenClaw because the underlying tool result already carries error information or an error payload; the UI was not consistently surfacing it.

Change Type (select all)

• Bug fix
• Feature
• Refactor required for the fix
• Docs
• Security hardening
• Chore/infra

Scope (select all touched areas)

• Gateway / orchestration
• Skills / tool execution
• Auth / tokens
• Memory / storage
• Integrations
• API / contracts
• UI / DX
• CI/CD / infra

Linked Issue/PR

• Closes #
• Related [NemoClaw][macOS][CLI&UX] OpenClaw chat UI shows ✓ Completed on tool calls that returned error / "Tool not found" NVIDIA/NemoClaw#2621
• This PR fixes a bug or regression

Real behavior proof (required for external PRs)

• Behavior or issue addressed: chat tool cards and standalone tool-result summaries now show failed tool results as Tool error with error styling instead of Tool output / View with a success checkmark.
• Real environment tested: macOS local OpenClaw worktree; Vite UI harness with system Chrome; focused Vitest UI tests.
• Exact steps or command run after this patch:
  • node scripts/run-vitest.mjs ui/src/ui/chat/tool-cards.test.ts ui/src/ui/chat/tool-cards.node.test.ts ui/src/ui/chat/grouped-render.test.ts
  • pnpm exec oxfmt --check --threads=1 ui/src/ui/chat/tool-cards.ts ui/src/ui/chat/tool-cards.test.ts ui/src/ui/chat/tool-cards.node.test.ts ui/src/ui/types/chat-types.ts ui/src/styles/chat/tool-cards.css ui/src/ui/chat/grouped-render.ts ui/src/ui/chat/grouped-render.test.ts
  • git diff --check
  • codex review --base refs/remotes/tmp/openclaw-main-2621
  • Temporary Vite proof page rendered renderToolCardSidebar in Chrome with one JSON error result and one successful result.
• Evidence after fix (screenshot, recording, terminal capture, console output, redacted runtime log, linked artifact, or copied live output):
  • Vitest: Test Files 3 passed (3), Tests 66 passed (66).
  • Format: All matched files use the correct format.
  • Whitespace: git diff --check exited 0.
  • Codex review: I did not find a discrete regression in the modified surfaces.
  • Console output from the Chrome/Vite browser harness after the patch: cardCount=2, errorCards=1, errorActionText="View error", success card kept View.
• Observed result after fix: error payloads such as {"error":"missing_brave_api_key"} and exact Tool not found output render as failed tool UI, while normal outputs continue to render as successful output.
• What was not tested: full live OpenClaw agent plus Brave or NemoClaw sandbox end-to-end; earlier Linux latest-image repro was blocked by no space left on device while pulling the image.
• Before evidence (optional but encouraged): existing behavior treated top-level JSON error output as normal Tool output in grouped rendering and successful sidebar action copy.

Root Cause (if applicable)

• Root cause: the chat UI treated tool output text as successful unless the local rendering path explicitly knew otherwise, so common error payloads and standalone tool-result summaries were not consistently mapped to failed UI state.
• Missing detection / guardrail: focused UI tests did not assert that explicit error flags, JSON error payloads, Tool not found, and standalone collapsed tool results all render as errors.
• Contributing context (if known): OpenClaw has both explicit error flags (isError, is_error) and textual/JSON tool output surfaces, so the UI needs to respect both.

Regression Test Plan (if applicable)

• Coverage level that should have caught this:
  • Unit test
  • Seam / integration test
  • End-to-end test
  • Existing coverage already sufficient
• Target test or file:
  • ui/src/ui/chat/tool-cards.test.ts
  • ui/src/ui/chat/tool-cards.node.test.ts
  • ui/src/ui/chat/grouped-render.test.ts
• Scenario the test should lock in: explicit isError / is_error flags and fallback error outputs must render as Tool error with error styling in card, sidebar, expanded, and collapsed standalone summary paths.
• Why this is the smallest reliable guardrail: these tests cover the UI normalization/rendering functions that decide the visible state, without requiring a live tool provider.
• Existing test that already covers this (if any): existing tool card tests covered successful rendering; this PR extends them for failed rendering.
• If no new test is added, why not: N/A.

User-visible / Behavior Changes

Failed tool results now show error labels, error badges, failed empty-output copy, and View error actions in the chat UI.

Diagram (if applicable)

Before:
[tool result with error payload] -> [tool card] -> [Tool output / success checkmark]

After:
[tool result with error payload or isError flag] -> [tool card] -> [Tool error / error badge]

Security Impact (required)

• New permissions/capabilities? (Yes/No): No
• Secrets/tokens handling changed? (Yes/No): No
• New/changed network calls? (Yes/No): No
• Command/tool execution surface changed? (Yes/No): No
• Data access scope changed? (Yes/No): No
• If any Yes, explain risk + mitigation: N/A

Repro + Verification

Environment

• OS: macOS local development machine
• Runtime/container: local Node/pnpm UI workspace
• Model/provider: N/A
• Integration/channel (if any): OpenClaw chat UI rendering
• Relevant config (redacted): no secrets required

Steps

1. Render tool cards with a JSON error payload, an explicit error flag, and a successful output.
2. Render grouped standalone tool-result messages in collapsed and expanded states.
3. Run focused chat rendering tests, formatting, whitespace check, and Codex review.

Expected

• Failed tool results are visually and textually marked as errors.
• Successful tool results keep existing success copy and styling.

Actual

• Failed results render as Tool error, include error styling/badges, and use View error in the sidebar card action.
• Successful results still render as Tool output / View.

Evidence

Attach at least one:

• Failing test/log before + passing after
• Trace/log snippets
• Screenshot/recording
• Perf numbers (if relevant)

Human Verification (required)

What you personally verified (not just CI), and how:

• Verified scenarios:
  • JSON error payloads.
  • exact Tool not found output.
  • explicit isError and is_error flags.
  • isError: false combined with an error payload.
  • collapsed standalone tool-result summaries.
  • empty failed output sidebar copy.
  • successful outputs remain successful.
• Edge cases checked:
  • blank output is not treated as an error unless an explicit error flag is present.
  • non-JSON and JSON arrays are not treated as error payloads.
  • very large output skips fallback JSON parsing.
• What you did not verify:
  • full live OpenClaw agent plus external web-search provider end-to-end.
  • Linux latest-image repro after the local Linux host ran out of disk space while pulling the latest image.

Review Conversations

• I replied to or resolved every bot review conversation I addressed in this PR.
• I left unresolved only the conversations that still need reviewer or maintainer judgment.

Compatibility / Migration

• Backward compatible? (Yes/No): Yes
• Config/env changes? (Yes/No): No
• Migration needed? (Yes/No): No
• If yes, exact upgrade steps: N/A

Risks and Mitigations

• Risk: fallback JSON error detection could overclassify a successful tool output that intentionally returns a top-level truthy error field as data.
  • Mitigation: explicit isError / is_error flags are preferred, fallback parsing is bounded to top-level JSON objects and common known error shapes, and tests cover success outputs remaining unchanged.

AI-assisted: yes, implemented with Codex and reviewed with codex review.