feat(tui): FauxStep::Factory for live request-shape assertions

[mvanhorn]

Closes #2074.

Shape

pub enum FauxStep {
    Canned(CannedTurn),
    Factory(Box<dyn Fn(&MessageRequest) -> CannedTurn + Send + Sync>),
}

When a Factory step is dequeued, its closure runs against the real outgoing MessageRequest before the response stream is built, so any assert! panic surfaces directly from the client call rather than later in stream polling. No change to existing canned-turn callers.

Public surface

• MockLlmClient::new(Vec<CannedTurn>) and push_turn(CannedTurn) keep working — they wrap each turn in FauxStep::Canned.
• push_factory(closure) is new, for tests that want the Factory branch.
• Doc comment on FauxStep::Factory captures the V4 thinking-mode tool-call invariant (the v0.4.9-v0.5.1 reasoning_content drop that produced HTTP 400 on follow-up turns).

Tests

• New regression file crates/tui/tests/reasoning_content_replayed_after_tool_call.rs whose factory asserts the assistant tool-call turn carries a Thinking content block after a thinking + tool-call round. Mirrors the #[path = "..."] test-support pattern already used by integration_mock_llm.rs.
• One additional unit test in mock.rs (create_message_synthesizes_from_factory_turn) for the non-streaming path.
• Existing integration_mock_llm suite (27 tests) is unchanged and passes.

cargo test -p codewhale-tui --test reasoning_content_replayed_after_tool_call
  ... 20 passed; 0 failed
cargo test -p codewhale-tui --test integration_mock_llm
  ... 27 passed; 4 ignored
cargo fmt --check  ... clean

Known limitation

The new regression test asserts against a follow-up request the test itself assembles (with assistant_thinking_tool_call(...)), not one produced by the real turn-loop. That matches the issue's "Acceptance" wording (request.messages.last().reasoning_content.is_some()) and the integration_mock_llm.rs doc-comment which already notes the engine still holds a concrete Option<DeepSeekClient> rather than Arc<dyn LlmClient> — until that wiring lands, the mock can't be wedged into the real turn-loop. This PR delivers the FauxStep::Factory infrastructure the issue asks for; the engine-level wiring is the follow-up the integration_mock_llm.rs ignored tests already track.

AI was used for assistance.

[gemini-code-assist]

Code Review

This pull request enhances the MockLlmClient by introducing FauxStep, an enum that allows for both static canned responses and dynamic response generation via a factory closure. This update enables more sophisticated testing by allowing assertions on outgoing MessageRequest objects directly within the mock. A new integration test was also added to ensure that reasoning_content is preserved in follow-up requests after tool calls, specifically targeting DeepSeek V4 requirements. I have no feedback to provide.

[Hmbown]

Independent review:

API is clean: FauxStep::Canned | Factory(Box<dyn Fn(&MessageRequest) -> CannedTurn + Send + Sync>), internal VecDeque<FauxStep>, with push_factory as the new surface. Closure runs inside create_message[_stream] before stream construction, so assert! panics from the client call, not the consumer's .next().await — that's the real win over capture-then-assert, and it works.

PR body's own "known limitation" is honest: the regression test asserts on a follow-up MessageRequest the test itself assembles via assistant_thinking_tool_call(...), not one produced by the engine's turn-loop. So this lands the infrastructure for #2074 cleanly but does not yet exercise the V4 invariant against real engine output — the integration_mock_llm.rs ignored tests still gate that. Worth saying so in the merge commit.

Unit test create_message_synthesizes_from_factory_turn covers the non-streaming branch; factory storage/dequeue is exercised by both files. Coverage of the new surface is adequate.

v0.8.48 (#2256): merges clean — models.rs adds response_format: Option<serde_json::Value> with skip_serializing_if. The empty_request() helper in mock.rs gets it via auto-merge, but the new make_request() in reasoning_content_replayed_after_tool_call.rs will need response_format: None appended post-rebase or it'll fail to compile.