emitTextDelta() currently drops all response.output_text.* events unless the output item phase is exactly commentary or final_answer. Since OutputItem.phase is optional (unphased/legacy items are valid), this change will suppress streaming for normal assistant output when the server omits phase, and buffered deltas get discarded in flushPendingUnknownPhaseText() when the mapped phase stays undefined. Consider treating undefined phase as visible (emit deltas with no partial.phase and a signature that omits phase), and only suppress when phase resolves to commentary.

flushPendingUnknownPhaseText() sorts pending parts with a[0].localeCompare(b[0]) on keys like ${itemId}:${contentIndex}. This can misorder content indices lexicographically (e.g., :10 before :2), which could replay buffered text out of order when there are many content parts. Prefer sorting by numeric contentIndex (store it separately or parse it from the key) instead of string compare.

normalizeAssistantPhase() and encodeAssistantTextSignature() are duplicated here and in src/agents/openai-ws-message-conversion.ts. To avoid the two implementations drifting (signature format needs to stay consistent with parseAssistantTextSignature()), consider exporting/reusing the shared helpers instead of re-declaring them in both modules.

Keep buffered deltas until phase is known

In flushPendingUnknownPhaseText, the !itemPhase branch deletes all buffered text for that item, but this function is called on both response.output_item.added and response.output_item.done. Because phase is optional on output items, an early response.output_text.delta can be buffered, then dropped when an unphased output_item.added arrives; if no further delta is appended before output_item.done carries the phase, the initial streamed text is never emitted as text_delta. This causes missing leading output in exactly the late-map case this change is trying to fix.

Useful? React with 👍 / 👎.

Commentary phase not suppressed — emitTextDelta emits for all known phases

The guard if (!itemPhase) only suppresses events when the phase is unknown (undefined). Because normalizeAssistantPhase("commentary") returns the string "commentary" (truthy), this check evaluates to false for commentary items and the text_delta event is pushed to eventStream.

This directly contradicts the PR's stated Blocker 1 goal ("commentary buffered text stays suppressed") and the test "buffers early text deltas until phase metadata arrives and suppresses commentary output", which asserts zero text_delta events after a commentary item is identified. Both the late-map flush path and the early-map direct-emit path flow through this function, so commentary text leaks in both scenarios.

The fix is to change the condition from !itemPhase to itemPhase !== "final_answer" so that only final_answer text is forwarded:

This is a comment left during a code review.
Path: src/agents/openai-ws-stream.ts
Line: 928-931

Comment:
**Commentary phase not suppressed — `emitTextDelta` emits for all known phases**

The guard `if (!itemPhase)` only suppresses events when the phase is *unknown* (`undefined`). Because `normalizeAssistantPhase("commentary")` returns the string `"commentary"` (truthy), this check evaluates to `false` for commentary items and the `text_delta` event is pushed to `eventStream`.

This directly contradicts the PR's stated Blocker 1 goal ("commentary buffered text stays suppressed") and the test `"buffers early text deltas until phase metadata arrives and suppresses commentary output"`, which asserts zero `text_delta` events after a commentary item is identified. Both the late-map flush path and the early-map direct-emit path flow through this function, so commentary text leaks in both scenarios.

The fix is to change the condition from `!itemPhase` to `itemPhase !== "final_answer"` so that only `final_answer` text is forwarded:

```suggestion
              const itemPhase = normalizeAssistantPhase(outputItemPhaseById.get(params.itemId));
              if (itemPhase !== "final_answer") {
                return;
              }
```

How can I resolve this? If you propose a fix, please make it concise.

flushPendingUnknownPhaseText emits buffered commentary text instead of discarding it

When the resolved phase is "commentary" (truthy), if (!itemPhase) evaluates to false and execution falls through to the emitTextDelta loop. emitTextDelta has the same !itemPhase guard (see companion comment), so the accumulated commentary text is emitted as a text_delta event.

The suppression guard here should mirror the fix to emitTextDelta:

With this change, unknown-phase items and commentary items are both discarded from the pending buffer, while final_answer items are flushed and emitted as before.

This is a comment left during a code review.
Path: src/agents/openai-ws-stream.ts
Line: 957-965

Comment:
**`flushPendingUnknownPhaseText` emits buffered commentary text instead of discarding it**

When the resolved phase is `"commentary"` (truthy), `if (!itemPhase)` evaluates to `false` and execution falls through to the `emitTextDelta` loop. `emitTextDelta` has the same `!itemPhase` guard (see companion comment), so the accumulated commentary text is emitted as a `text_delta` event.

The suppression guard here should mirror the fix to `emitTextDelta`:

```suggestion
            const flushPendingUnknownPhaseText = (itemId: string) => {
              const itemPhase = normalizeAssistantPhase(outputItemPhaseById.get(itemId));
              if (itemPhase !== "final_answer") {
                pendingUnknownPhaseTextByPart.forEach((_, key) => {
                  if (key.startsWith(`${itemId}:`)) {
                    pendingUnknownPhaseTextByPart.delete(key);
                  }
                });
                return;
              }
```

With this change, unknown-phase items *and* commentary items are both discarded from the pending buffer, while `final_answer` items are flushed and emitted as before.

How can I resolve this? If you propose a fix, please make it concise.

Keep prior phase when output item updates are unphased

This handler resets outputItemPhaseById to undefined whenever an item update arrives without item.phase, even if an earlier response.output_item.added already established final_answer. In that case, later response.output_text.done events for the same item are treated as unknown-phase, buffered, and then flushed on completion with deltaText equal to the full accumulated text, which can replay already-streamed content and duplicate user-visible output.

Useful? React with 👍 / 👎.

Keep done-message phase usable for mixed commentary/final output

This change removes the top-level assistant phase whenever a response includes mixed phases, but downstream delivery logic suppresses visibility based on the first phased text block when top-level phase is absent. For the common ordering of commentary first then final answer, handleMessageEnd can classify the whole message as commentary and return early; if no prior streamed assistant update was emitted, the final answer is dropped entirely.

Useful? React with 👍 / 👎.