Understanding Comma-to-Newline Chat Display Change
Understanding Comma-to-Newline Chat Display Change
Agent
Claude Code
Model
Claude Opus 4.6
Shared
Feb 18, 12:58 AM
Messages30
Downloads6
i'm viewing a chat replay and i see that we are somehow parsing a comma and turning it into a newline in the chat display. this is the final event output but we build up the chat with deltas so the user can see the info streaming in. what is happening here?
{ "timestamp": "2026-02-17T21:16:00.224Z", "type": "response_item", "payload": { "type": "message", "role": "assistant", "content": [ { "type": "output_text", "text": "The active RFC is currently just a blank template, so I’m inspecting project architecture and existing RFC patterns to produce a concrete, repo-aligned plan with defaults filled in." } ], "phase": "commentary" } } { "timestamp": "2026-02-17T21:16:00.223Z", "type": "event_msg", "payload": { "type": "agent_message", "message": "The active RFC is currently just a blank template, so I’m inspecting project architecture and existing RFC patterns to produce a concrete, repo-aligned plan with defaults filled in." } }
Here's the problem. In ChatMessageList.tsx:27-43, the splitSentences() function has a comma-splitting fallback:
function splitSentences(text: string): string[] { const normalized = text.replace(/\s+/g, " ").trim(); // First tries sentence boundaries (.!?) const rough = normalized .split(/(?<=[.!?])\s+(?=[A-Z0-9`"'([])/) ... if (rough.length > 1) { return rough; } // Falls back to splitting on COMMAS return normalized .split(/,\s+(?=[a-z])/i) ...}The text in your example is a single sentence (one period at the end), so the first regex split produces only 1 part. It then falls through to the comma fallback, which splits on , so and , repo-aligned.
Then paragraphize() (line 65) groups those comma-split fragments into separate paragraphs, which renders them on separate lines with gaps between them.
The comma fallback was probably intended to break up long comma-separated lists, but it's incorrectly breaking up normal prose that happens to have commas. The fix is to remove or restrict that comma-splitting fallback. What would you like to do — remove it entirely, or restrict it to only fire when there are many comma-separated items (like 4+)?
where did splitSentences come from in the commit history?
>git log --all --oneline -n 20 -- electron_app/src/renderer/features/chat/components/ChatMessageList.tsx>git log --all --oneline -S "splitSentences" -- electron_app/src/renderer/features/chat/components/ChatMessageList.tsx[Image: source: /Users/josh/Library/Application Support/CleanShot/media/media_VTK6nLMAGe/CleanShot 2026-02-17 at 14.31.40@2x.png]
>git show d7e1205 --stat && echo "---" && git show d7e1205 --format="%H %ai %an%n%s%n%b" | head -5>git show d7e1205 -- electron_app/src/renderer/features/chat/components/ChatMessageList.tsxIt was introduced by Ayman on Feb 12 in commit d7e1205 ("Update ChatMessageList.tsx"). The entire splitSentences, collapseNearDuplicateSentences, paragraphize, and normalizeSentence suite was added in that single commit.
The intent was to break up long assistant messages into readable paragraphs — splitting first on sentence boundaries (.!?), then falling back to comma splitting when there's only a single sentence. The comma fallback is what's causing your bug: single-sentence prose with commas gets split into separate paragraph blocks.
what other commits happened around then
>git log --all --oneline --since="2026-02-12" --until="2026-02-13" --author="Ayman">git log --all --format="%h %ai %s" --since="2026-02-11" --until="2026-02-14" --author="Ayman"The user is seeing commas being turned into newlines in the chat replay display. Let me look at the ReplayChatView component to understand how chat messages are built up from deltas.
It was part of a UI polish sprint on Feb 12. The sequence that day was:
bdac0d3 — "take ai response out of text bubble"d7e1205 — "Update ChatMessageList.tsx" (introduced splitSentences + paragraphize)f669a99 — "take ai response out of text bubble" (duplicate on another branch)e85c5b6 — "Update ChatMessageList.tsx" (duplicate)8c1fa19 / fa30536 — "chat appearance"4b85ea5 / 2581f4b — "move disambiguation into inline chat"It looks like Ayman was restyling the chat — removing the bubble/card treatment for assistant messages and switching to a more open layout. The splitSentences/paragraphize logic was added as part of making the bubble-less text more readable by breaking long blocks into visual paragraphs. The comma fallback was likely meant to handle cases where the AI produces a single long sentence, but it's too aggressive for normal prose.
Perfect! Now I have all the information I need. Let me create a comprehensive summary of my findings:
## Summary
Based on my search of the codebase, here are the key files and code patterns related to how chat messages are built up from deltas/streaming events in the replay and codex session context:
### 1. **Text Delta Accumulation for Chat Messages**
**File:** `/Users/josh/Code/rfc/electron_app/src/main/services/appController/chatDomain.ts`
The primary function that accumulates text deltas into chat messages is `applyToken()` (lines 362-386):
```typescript
export async function applyToken(ctx: ChatDomainContext, delta: string, requestId: string): Promise<void> {
const run = ctx.getActiveChatRun(requestId);
if (!run) {
return;
}
const specUi = ctx.getSpecUi(run.workspaceId, run.specId);
if (!specUi) {
return;
}
const isCurrentSpec = ctx.isCurrentSpec(run.workspaceId, run.specId);
const targetMessages = specUi.chatMessages;
const idx = findLastIndex(
targetMessages,
(message) => message.role === "assistant" && message.requestId === requestId && message.isStreaming === true
);
if (idx < 0) {
return;
}
targetMessages[idx].content += delta; // <-- TEXT ACCUMULATION HERE
if (isCurrentSpec && !ctx.isSelectingSpec()) {
ctx.emitSnapshot();
}
}
```
The key line is `targetMessages[idx].content += delta;` which directly appends incoming text deltas to the message content.
### 2. **Delta Extraction and Multi-Item Message Handling**
**File:** `/Users/josh/Code/rfc/electron_app/src/main/services/codexRunner/notificationHandlers.ts` (lines 212-241)
The `item/agentMessage/delta` notification handler accumulates text from multiple agent message items:
```typescript
if (method === "item/agentMessage/delta") {
const delta = args.extractDeltaText(params, item);
if (!delta || !run) {
return;
}
const isNewItem = itemId && !run.agentMessageTextByItemId.has(itemId);
if (itemId) {
const previous = run.agentMessageTextByItemId.get(itemId) ?? "";
run.agentMessageTextByItemId.set(itemId, `${previous}${delta}`); // <-- ACCUMULATION
}
if (isNewItem && run.agentMessageItemCount > 0) {
run.onToken("\n\n"); // <-- NEWLINE INSERTION BETWEEN ITEMS
}
if (isNewItem) {
run.agentMessageItemCount += 1;
}
run.onToken(delta);
return;
}
```
**Important:** When a new agent message item starts (after the first one), the handler inserts `"\n\n"` to separate multiple agent messages (line 224).
### 3. **Delta Text Extraction**
**File:** `/Users/josh/Code/rfc/electron_app/src/main/services/codexRunner/protocolParsers.ts` (lines 284-301)
```typescript
export function extractDeltaText(params: Record<string, unknown>, item: Record<string, unknown>): string | undefined {
const deltaObj = params.delta as Record<string, unknown> | undefined;
if (deltaObj) {
const text = readString(deltaObj.text) || readString(deltaObj.content);
if (text) {
return text;
}
}
return (
readString(params.delta) ||
readString(params.text) ||
readString(params.content) ||
readString(item.text) ||
readString(item.content) ||
readString(((params.message as Record<string, unknown> | undefined) ?? {}).text)
);
}
```
### 4. **Chat Message Structure**
**File:** `/Users/josh/Code/rfc/electron_app/src/shared/models.ts` (lines 61-70)
```typescript
export interface ChatMessage {
id: string;
role: ChatRole;
content: string;
timestamp: ISODateString;
requestId?: string;
isStreaming?: boolean;
error?: string;
activity?: ActivityPayload;
}
```
Chat messages are stored with a simple `content: string` field that gets accumulated.
### 5. **Comma-to-Newline Pattern (Sentence Splitting)**
**File:** `/Users/josh/Code/rfc/electron_app/src/renderer/features/chat/components/ChatMessageList.tsx` (lines 27-43)
The rendering layer has a `splitSentences()` function that **splits on commas**:
```typescript
function splitSentences(text: string): string[] {
const normalized = text.replace(/\s+/g, " ").trim();
if (!normalized) {
return [];
}
const rough = normalized
.split(/(?<=[.!?])\s+(?=[A-Z0-9`"'([])/) // <-- First tries to split on sentence boundaries
.map((part) => part.trim())
.filter(Boolean);
if (rough.length > 1) {
return rough;
}
return normalized
.split(/,\s+(?=[a-z])/i) // <-- FALLS BACK TO SPLITTING ON COMMAS
.map((part) => part.trim())
.filter(Boolean);
}
```
This is used by `paragraphize()` for rendering assistant messages, converting comma-separated items into separate lines for display purposes.
### 6. **Codex Session Log Text Extraction**
**File:** `/Users/josh/Code/rfc/electron_app/src/replay/views/ReplayCodexSessionView.tsx` (lines 408-451)
When extracting searchable text from Codex session entries, parts are **joined with newlines**:
```typescript
function extractSearchableText(entry: CodexSessionEntry): string {
const parts: string[] = [];
const payload = entry.payload;
if (typeof payload.message === "string") {
parts.push(payload.message);
}
if (typeof payload.text === "string") {
parts.push(payload.text);
}
// ... more field extraction ...
return parts.join("\n"); // <-- JOINS WITH NEWLINES
}
```
This is used for search functionality in the Codex session viewer, not for building actual chat messages.
### Key Findings:
1. **Text accumulation** happens through simple string concatenation: `content += delta`
2. **Newlines between items** are explicitly inserted when new agent message items start
3. **Comma splitting** only happens at the **rendering layer** for display purposes, not during message accumulation
4. **No comma-to-newline conversion** occurs during the streaming/delta accumulation process itself
5. The codex session searchable text uses newline joins for combining multiple text fields, but this is separate from chat message construction
agentId: a2722a4 (for resuming to continue this agent's work if needed)
<usage>total_tokens: 74515
tool_uses: 36
duration_ms: 84457</usage>The agent found the issue. There's a splitSentences() function in ChatMessageList.tsx that splits on commas and renders them as separate paragraphs. Let me look at that code directly.
Found it. The issue is in the rendering layer. Let me look at the exact code.
function splitSentences(text: string): string[] { const normalized = text.replace(/\s+/g, " ").trim(); // First tries sentence boundaries (.!?) const rough = normalized .split(/(?<=[.!?])\s+(?=[A-Z0-9`"'([])/) ... if (rough.length > 1) { return rough; } // Falls back to splitting on COMMAS return normalized .split(/,\s+(?=[a-z])/i) ...}