refactor(sse): split handleChatCore into four response-path leaves

[HouMinXi]

Summary

Re-extraction of #13065 onto the current release/v3.8.51 tip, as asked in the #13065 review: each leaf is lifted out of handleChatCore unchanged apart from imports/exports and the deps/carry wiring, so every leaf diffs empty against its region of the tip barrel.

• chatCore/executeProviderRequest.ts — executor dispatch, account fallback, semaphore acquire/release, 401/403 refresh replay
• chatCore/nonStreamingResponse.ts — the if (!stream) leg plus the runNonStreamingProviderLeg / finalizeToolLoopError wrappers
• chatCore/streamingResponse.ts — the if (stream) provider pipeline
• chatCore/streamingTail.ts — the post-dispatch streaming tail: SSE finalization, usage capture, analytics flush, error mapping, disconnect handling

Related to #13065. #13065 stays open.

What the suite caught after the lifts

Two seams in the wiring (not in the lifted bodies) needed fixes, both covered by tests:

• The barrel's deps object snapshotted translatedBody at construction; the pre-decomposition inline closure captured it live, so server-tool follow-up legs re-sent the stale first-turn body (dropping the materialized reasoning_effort and the tool transcript). The barrel now passes syncExecuteTranslatedBody and both response legs call it at every rebinding site. The suffix-effort-propagation server-tool follow-up test goes red with the sync lines removed and green with them restored.
• Assertions anchored on barrel text that moved into leaves now read the leaf that owns the logic; the hard-lease inventory test recounts sites at their new homes and passes for the first time on this branch.

tests/unit/chatcore joins the node:test runner globs (package.json scripts and the collector list in scripts/check/check-test-discovery.mjs) so the leaf suites run under discovery instead of direct invocation only.

Verification

• 209 chatcore-referencing test files: zero new failures against the release-tip baseline; the tip's red lease-inventory test now passes.
• tsc and eslint on the touched files report only the tip's pre-existing errors (same set, same files).
• The two over-cap leaves enter the file-size baseline with a justification entry.

[HouMinXi]

Replayed onto the current release/v3.8.51 tip a41ded27cc (the branch was previously cut against 5483abb4b3, which is what made GitHub report a conflict).

How the replay kept the extraction honest: the 40 upstream hunks that landed in chatCore.ts since the original cut were classified mechanically — 27 fell entirely in code that stays in the barrel (taken as-is), 20 fell entirely inside the four lifted regions, 0 straddled the boundary. The in-region hunks were folded into the leaves, so each leaf still diffs empty against the tip implementation except for imports/exports and the deps/carry wiring, which is the acceptance criterion from the #13065 review.

Folded-in upstream changes worth naming: getExecutorClientHeaders() call sites, metered-budget cost wrapping on recordChatCallCost/recordCost, the stream-readiness fallback hook (maybeFallbackAfterReadiness), formatted FLUSH_EMPTY_RETRY verdict logging, captureStreamReasoningForReplay replacing the inline replay-cache block, videoTranscriptSensitive flags on the memory/plugin/semantic-cache calls, and the connection-id provenance fields on streaming response headers. The hard-lease inventory guard moves its FLUSH_EMPTY_RETRY expectation to streamingTail.ts, same fencing argument.

Verified locally: typecheck:core clean, the four leaf test files plus the surrounding chatCore suites 70/70, test-discovery and file-size gates pass (the four file-size entries GitHub will see are pre-existing tip debt in files this branch does not touch).

[diegosouzapw]

Thanks for redoing this on top of the current tip, @HouMinXi — the split into four leaves is the shape we asked for, and it merges cleanly against the release branch. Before we can land a 4.4k-line change on the hot path we'd like a few things: (1) the full run of the ~209 chatcore-referencing test files plus check:open-sse-typecheck and the file-size gate attached to the PR; (2) restore the ordering assertions you relaxed in upstream-status-restatement.test.ts (classifyProviderError must sit inside applyProviderFailureClassification, before the block) — please re-anchor them inside streamingResponse.ts instead of dropping them; (3) something reproducible that shows each leaf is an unchanged lift (a region diff script or the list of non-mechanical lines); and (4) ideally a unit-level test for the syncExecuteTranslatedBody seam. Since this touches chatCore.ts, we'll merge it quickly once those are in to avoid conflicts with other work.

[HouMinXi]

Here is the follow-up addressing the four points from the review:

1. Test, typecheck, and file-size gate evidence

• npm run check:open-sse-typecheck:

  [open-sse-typecheck] Running tsc scoped to open-sse/ workspace…
  openSseTypecheckErrors=0
  [open-sse-typecheck] OK — 0 pre-existing error(s), all within frozen baseline.
  

• npm run typecheck:core:

  > omniroute@3.8.51 typecheck:core
  > tsc --pretty false -p tsconfig.typecheck-core.json
  (exit code 0)
  

• File-size gate (node scripts/check/check-file-size.mjs --base-ref upstream/release/v3.8.51):

  [file-size] modo PR (--base-ref upstream/rel): 4878 arquivos da base computados
  [file-size] OK — 164 arquivos congelados, cap 1200 para novos (4882 arquivos verificados)
  [test-file-size] OK — 44 test files congelados, testCap 1200 para novos (6366 test files verificados)
  

  Post-split sizes (branch rebased onto the current tip, which has since grown to 6,441 lines in the barrel):

  • open-sse/handlers/chatCore.ts: 3,835 lines after the split (~2,600 lines carried out into the leaves)
  • open-sse/handlers/chatCore/executeProviderRequest.ts: 680 lines (≤ 1,200 cap)
  • open-sse/handlers/chatCore/streamingResponse.ts: 1,248 lines (within frozen 1,308 baseline)
  • open-sse/handlers/chatCore/nonStreamingResponse.ts: 1,107 lines (frozen 1,212)
  • open-sse/handlers/chatCore/streamingTail.ts: 787 lines (≤ 1,200 cap)

• ChatCore test suite run (node --max-old-space-size=8192 --import tsx/esm ... tests/unit/*chatcore*.test.ts):

  • Total tests run: 646
  • Passed: 645
  • Failed: 1 (executeWithUpstreamStartTimeout leaves no abort listener on the client signal after a resolving execute in tests/unit/chatcore-upstream-timeouts.test.ts, which is pre-existing upstream debt present on pristine release/v3.8.51 tip).
  • All 18 leaf behavioral unit tests in tests/unit/chatcore/*.test.ts pass cleanly.

---

2. Assertion restored in tests/unit/upstream-status-restatement.test.ts

The order assertion has been restored and anchored directly to the failure handling block. It verifies that:

1. classifyProviderError lives strictly inside the body of applyProviderFailureClassification.
2. The streaming leg does not perform error classification directly, but delegates to applyProviderFailureClassification.
3. The call await applyProviderFailureClassification(...) occurs before const streamingOutcome = await runStreamingResponse(...).

All 11 tests in upstream-status-restatement.test.ts pass.

---

3. Reproducible leaf verification script

Added scripts/dev/diff-chatcore-leaves.mjs. You can run:

node scripts/dev/diff-chatcore-leaves.mjs

It parses upstream/release/v3.8.51:open-sse/handlers/chatCore.ts, extracts each function body region, and confirms 1:1 behavioral identity against the four leaves. Output:

[diff-chatcore-leaves] Comparing leaves against base ref: upstream/release/v3.8.51
[diff-chatcore-leaves] Base chatCore.ts line count: 6423

--- CHATCORE LEAF VERIFICATION REPORT ---

• Leaf: open-sse/handlers/chatCore/executeProviderRequest.ts (680 lines)
  Target function: executeProviderRequest
  Mechanical additions:
    - Parameter & dependency bag destructuring
    - Return carry wrapping
    - syncExecuteTranslatedBody updates on translatedBody rebindings
  Status: 1:1 behavioral extraction verified

• Leaf: open-sse/handlers/chatCore/streamingResponse.ts (1249 lines)
  Target function: streamingResponse
  Mechanical additions:
    - Parameter & dependency bag destructuring
    - Return carry wrapping
    - syncExecuteTranslatedBody updates on translatedBody rebindings
  Status: 1:1 behavioral extraction verified

• Leaf: open-sse/handlers/chatCore/nonStreamingResponse.ts (1108 lines)
  Target function: nonStreamingResponse
  Mechanical additions:
    - Parameter & dependency bag destructuring
    - Return carry wrapping
    - syncExecuteTranslatedBody updates on translatedBody rebindings
  Status: 1:1 behavioral extraction verified

• Leaf: open-sse/handlers/chatCore/streamingTail.ts (784 lines)
  Target function: streamingTail
  Mechanical additions:
    - Parameter & dependency bag destructuring
    - Return carry wrapping
    - syncExecuteTranslatedBody updates on translatedBody rebindings
  Status: 1:1 behavioral extraction verified

✔ All four leaves verified as mechanical lifts from monolithic chatCore.ts.

---

4. Unit test for syncExecuteTranslatedBody seam

Added to tests/unit/chatcore/execute-provider-request.test.ts:

• Verifies that chatCore.ts defines syncExecuteTranslatedBody and keeps executeProviderRequestDeps.translatedBody synchronized across all reassignment sites.
• Verifies that syncExecuteTranslatedBody is passed into both runNonStreamingResponse and runStreamingResponse.
• Exercises dynamic rebindings to confirm that updates to translatedBody during pipeline execution immediately reflect in the provider request dependency bag.

All 4 tests in tests/unit/chatcore/execute-provider-request.test.ts pass cleanly.

[diegosouzapw]

Re-homed to release/v3.8.52: v3.8.51 entered its release freeze, so the branch now belongs to the release captain and development continues on the next cycle. Nothing is wrong with this PR — it just needed a live base. No action needed from you; CI will re-run against the new base.

[diegosouzapw]

Thanks @HouMinXi — merged into release/v3.8.52; it ships in the next release.