refactor: modularize combo (non-stacked)

[oyi77]

Replaces #3798 as an independent, non-stacked PR branched from release/v3.8.27.

Extracts combo.ts into modular structure.

Supersedes: #3798

[gemini-code-assist]

Code Review

This pull request modularizes the combo routing logic under open-sse/services/combo/ by splitting it into specialized modules for auto-routing, round-robin, quota management, context filtering, DAG resolution, and shadow routing. The review feedback highlights several critical issues: a potential memory leak in chat.ts due to an unremoved abort event listener, a resource leak in shadow.ts from draining a cloned response instead of the original, and a compatibility risk in sorting.ts from using Array.prototype.at(). Additionally, the reviewer noted a violation of the repository style guide requiring tests for any production code changes.

Important

The consumer version of Gemini Code Assist on GitHub is being sunset. Starting June 18, 2026, new organization installations will be blocked, and all code review activity will officially cease on July 17, 2026.
For more details on the timeline and next steps, please review the Help Documentation.

[gemini-code-assist]

The event listener added to target.modelAbortSignal is never removed. If target.modelAbortSignal is long-lived or if many speculative/hedged tasks are created during a request, this can lead to memory leaks and accumulation of event listeners.

Please ensure that the event listener is cleaned up in the finally block.

    let abortListener: (() => void) | undefined;
    if (target?.modelAbortSignal) {
      if (target.modelAbortSignal.aborted) {
        timeoutController.abort(new Error("hedge-cancelled"));
      } else {
        abortListener = () => {
          timeoutController.abort(new Error("hedge-cancelled"));
        };
        target.modelAbortSignal.addEventListener("abort", abortListener);
      }
    }
    try {
      return await Promise.race([
        handleSingleModel(b, modelStr, targetWithSignal).catch((err) => {
          if (timedOut) {
            // Inner call rejected because we aborted it. The synthetic 524 from
            // timeoutPromise already wins the race; return an empty response so
            // the loser branch resolves cleanly without leaking err.message.
            return new Response(null, { status: 599 });
          }
          return errorResponse(502, err?.message ?? "Upstream model error");
        }),
        timeoutPromise,
      ]);
    } finally {
      clearTimeout(timeoutId);
      if (target?.modelAbortSignal && abortListener) {
        target.modelAbortSignal.removeEventListener("abort", abortListener);
      }
    }

[gemini-code-assist]

Using response.clone() and then draining the clone leaves the original response body stream unconsumed. In many fetch environments (like Node.js/undici), unconsumed response bodies can cause socket and resource leaks.

Since the original response body is not needed elsewhere (only response.ok and response.status are read), you should drain the original response directly and avoid cloning it entirely.

Suggested change

	await drainShadowResponse(response.clone());
	await drainShadowResponse(response);

[gemini-code-assist]

Using Array.prototype.at() requires ES2022 support. If the project's target environment or transpiler configuration is older and does not include polyfills, this can cause runtime crashes.

Using standard array indexing targets[targets.length - 1] is safer and fully backward-compatible.

Suggested change

	return targets.at(-1);
	return targets[targets.length - 1];

[gemini-code-assist]

According to Rule 9 of the Repository Style Guide:

Always include tests when changing production code (src/, open-sse/, electron/, bin/).

Since this PR introduces a major modularization of the combo routing logic under open-sse/services/combo/, please ensure that corresponding unit or integration tests are added or updated under the tests/ directory to maintain coverage and prevent regressions.

References

1. Always include tests when changing production code (src/, open-sse/, electron/, bin/). ^(link)

[diegosouzapw]

Thanks @oyi77 — blockers for the combo modularization:

1. Sub-split: combo/chat.ts (1623) and combo/quota.ts (850) exceed the 800-line new-file cap (Fast Quality Gates red).
2. Verify lossless + rebase onto current release/v3.8.27. combo is the routing core (15 strategies, auto-combo scoring, sticky RR) and recent fixes landed here this cycle (feat(combo): add sticky round-robin target limit #3846 sticky-RR, Fix/candidate pool empty array #3871 empty-pool, [BUG] Only a few models are routed to in combo event in strict random strategy #3959 strict-random shuffle). Siblings dropped content (refactor: modularize provider registry (non-stacked) #3993 dropped 2 providers, refactor: modularize usage (non-stacked) #3989 dropped the vertex usage fetcher), so a silently-dropped strategy/handler here would break routing. Please diff every strategy/handler + export monolith-vs-modules and confirm full parity before re-review.

[diegosouzapw]

Thanks for all the modularization work here, @oyi77 🙏. We've decided to hold the per-module "non-stacked" refactors and run the decomposition as one coordinated pass after the in-flight quality-gate work lands, instead of merging them piecemeal. Reason: on the two we did merge (#3993, #3988) we caught logic being dropped during the move — and the gates (provider-consistency / typecheck) don't detect internal-logic loss — so each of these needs a full lossless audit, which isn't tractable across many overlapping PRs against a moving release branch right now. The coordinated modularization is tracked in #3501 / #3594; we'd genuinely value your input on that plan once it's up. Closing for now — purely sequencing, not a reflection on the effort.