fix: resolve Claude Code provider JSON parsing and reasoning block display

[hannesrudolph]

Description

Fixes the Claude Code provider showing raw JSON output instead of properly parsed content. This PR addresses two key issues that were causing poor user experience with the Claude Code integration.

Changes Made

• JSON Buffering Fix: Implemented proper line-based buffering in src/api/providers/claude-code.ts to handle incomplete data chunks that were causing JSON parsing failures
• Reasoning Block Display: Changed thinking content to yield as "reasoning" type instead of "text" type so it renders as collapsible reasoning blocks in the UI
• Type System Enhancement: Extended ClaudeCodeContent type in src/integrations/claude-code/types.ts to support both text and thinking content
• Comprehensive Testing: Added full test suite in src/api/providers/__tests__/claude-code.spec.ts covering thinking content, mixed content, and error scenarios

Testing

• All existing tests pass
• Added comprehensive test coverage for Claude Code provider:
  • Thinking content properly yields as "reasoning" type
  • Mixed content types handled correctly
  • Error scenarios with thinking content
• Manual testing completed:
  • JSON parsing no longer fails on incomplete chunks
  • Thinking content displays as collapsible reasoning blocks
  • No more raw JSON output in chat

Technical Details

JSON Buffering Implementation:

// Before: Direct JSON parsing caused failures on incomplete chunks
JSON.parse(data.toString())

// After: Line-based buffering handles incomplete data properly
lines.forEach(line => {
  if (line.trim()) {
    const parsed = JSON.parse(line)
    // Process parsed data...
  }
})

Reasoning Block Fix:

// Before: Thinking content displayed as raw text
if (content.type === "thinking") {
  yield { type: "text", text: content.thinking }
}

// After: Thinking content displays as collapsible reasoning blocks
if (content.type === "thinking") {
  yield { type: "reasoning", text: content.thinking }
}

Verification of Fix

• UI Integration: Confirmed ChatRow.tsx has proper case "reasoning": handling that renders ReasoningBlock components
• Type Safety: All TypeScript types properly support the new content structure
• Backward Compatibility: No breaking changes to existing functionality

Checklist

• Code follows project style guidelines
• Self-review completed
• Comments added for complex logic
• All tests pass with comprehensive coverage
• No breaking changes
• ESLint warnings resolved
• TypeScript checks pass

---

Important

Fix JSON parsing and reasoning block display in Claude Code provider by implementing line-based buffering and updating content types.

• JSON Parsing:
  • Implement line-based buffering in claude-code.ts to handle incomplete JSON data.
  • Add isLikelyValidJSON() to validate JSON before processing.
• Reasoning Block Display:
  • Change thinking content to yield as "reasoning" type in claude-code.ts.
  • Update ClaudeCodeContent type in types.ts to support thinking content.
• Testing:
  • Add tests in claude-code.spec.ts for thinking content, mixed content, and error scenarios.
• Misc:
  • Add getContentText() in claude-code.ts to extract text from content objects.
  • Improve error logging in attemptParseChunk() in claude-code.ts.

^{This description was created by for dd9e146. You can customize this summary. It will automatically update as commits are pushed.}

[Copilot]

Pull Request Overview

This pull request fixes the JSON buffering issue and corrects the display of thinking content by yielding it as a "reasoning" type, improving the integration with the Claude Code provider. The key changes include:

• Implementing line-based buffering in src/api/providers/claude-code.ts to handle incomplete JSON chunks.
• Modifying the thinking content handling to yield "reasoning" instead of "text" in src/api/providers/claude-code.ts.
• Extending the ClaudeCodeContent type in src/integrations/claude-code/types.ts to support the new thinking content.
• Adding comprehensive tests in src/api/providers/tests/claude-code.spec.ts to cover mixed, thinking, and error scenarios.

Reviewed Changes

Copilot reviewed 3 out of 3 changed files in this pull request and generated no comments.

File	Description
src/integrations/claude-code/types.ts	Extended ClaudeCodeContent union type to include thinking content.
src/api/providers/claude-code.ts	Added buffering to process incoming data and updated reasoning block display.
src/api/providers/tests/claude-code.spec.ts	Added tests to verify thinking content and mixed content handling.

[daniel-lxs]

Is this type assertion necessary? Since you've already extended the ClaudeCodeContent type to include thinking content, TypeScript should handle this properly without the cast to any.

If there are other content types not covered in the type definition, would it be better to add them to the ClaudeCodeContent union type for better type safety?

[daniel-lxs]

The tests use hardcoded setTimeout delays which could be flaky in CI environments. Have you considered using a more deterministic approach? For example:

// Instead of setTimeout, use immediate execution
mockProcess.stdout.emit("data", JSON.stringify(thinkingResponse) + "\n")
mockProcess.emit("close", 0)

// Or use a test utility for controlled async behavior
await nextTick() // or similar

This would make the tests more reliable and faster to execute.

[daniel-lxs]

I noticed an inconsistency in how empty lines are handled. Here you trim before checking if the line is empty, but in line 56 you check buffer.trim().

Would it be cleaner to handle this consistently? Perhaps:

// Process complete lines
for (const line of lines) {
  const trimmedLine = line.trim()
  if (trimmedLine !== "") {
    dataQueue.push(trimmedLine)
  }
}

And similarly for the buffer check in the close handler.

[daniel-lxs]

LGTM