Build one AsyncOpenAI and one Compactor per engine run

[declanatinference]

Summary

• Engine reads engine_config.model_provider in exactly one place (engine.main.stream_engine_async), builds the AsyncOpenAI + Compactor once per run, installs the SDK default with use_for_tracing=False, and stashes both on EngineRunState so the subagent path reuses them.
• OpenAiAgentRunner now takes a Compactor directly — the compactor_factory indirection and its unused AgentExecution arg are gone.
• The per-run AsyncOpenAI is closed in stream_engine_async's outer finally, wrapped in try/except so close-time errors can't mask in-flight exceptions.
• Deletes configure_default_sdk_client, build_compactor_factory, the CompactorFactory alias, and SynthesisTool's lazy-construct branch.
• Test cleanup: shared noop_compactor exported from tests.probes.probe_kit (collapses 7 duplicate local stubs); build_compactor monkeypatch replaces the deeper build_compactor_factory patch; the subagent test no longer needs its own monkeypatch since EngineRunState carries the compactor.

Closes INF-2933 items 8 and 9.

Test plan

• uv run pytest -q — 276 passed (baseline 278 − 3 deleted test_configure_default_sdk_client_* + 1 new SDK-default test)
• uv run pytest tests/integration -q — 54 passed (+ 2 new lifecycle tests in test_engine_client_lifecycle.py covering normal exit and early consumer break). One pre-existing live-API flake unrelated to this change.
• Stale-reference greps clean: configure_default_sdk_client, build_compactor_factory, compactor_factory, CompactorFactory all zero hits across engine/ and tests/.
• basedpyright clean on the changed engine files.

Behaviour changes (intentional)

1. SDK default is always installed. Previously skipped when base_url, api_key, and default_headers were all None. Now always installs AsyncOpenAI(...) (equivalent to env-driven AsyncOpenAI() in that case) with use_for_tracing=False.
2. Provider misconfiguration fails eagerly. If OPENAI_API_KEY is missing and model_provider.api_key is None, AsyncOpenAI() raises at engine startup instead of lazily on first compactor/synthesis call.
3. Connection pool closed on run exit. await client.close() in stream_engine_async's outer finally — no behaviour change visible from the public API, just cleaner httpx lifecycle.

---

Note

Medium Risk
Medium risk because it changes engine startup/client lifecycle (eager AsyncOpenAI construction, global set_default_openai_client, and explicit close() teardown) and rewires compaction/synthesis call paths used by both root and subagents.

Overview
The engine now creates a single per-run AsyncOpenAI client in stream_engine_async, installs it as the Agents SDK default with use_for_tracing=False, stores it on EngineRunState, and closes it on run teardown (including early consumer break) with close failures logged but not raised.

Compaction is refactored from a pluggable callable/factory into a direct call to engine.agents.compactor.compact(client, compaction_model, item): AgentContext.compact_old_items now takes the run client, OpenAiAgentRunner takes the client directly, and the old build_compactor_factory/CompactorFactory indirection is removed. SynthesisTool similarly stops lazily constructing its own client and instead requires the injected run client (wired from run_state.openai_client).

The previous test seam via RunnerProtocol and a per-run runner arg is removed; tests/probes now patch agents.Runner.run_streamed (via a new install_fake_runner helper), add coverage for SDK default installation + client close lifecycle, and set a placeholder OPENAI_API_KEY for non-live test runs to satisfy eager client construction.

^{Reviewed by Cursor Bugbot for commit 44c492b. Bugbot is set up for automated code reviews on this repo. Configure here.}

[francescov1]

Id avoid builder methods for simple functions, instead expose a pure function like async def compact(client: AsyncOpenAI, engine_config: EngineConfig, item: AgentContextItem) -> str so that we dont need to be nesting functions and passing them around. Or if too much context to drill down we can create a compactor class which is initialized in the same place we call build_compactor and then passed around.

[cursor]

Cursor Bugbot has reviewed your changes and found 1 potential issue.

^{❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.}

^{Reviewed by Cursor Bugbot for commit 44c492b. Configure here.}

[cursor]

Test stub missing type annotations on parameters

Low Severity

The fake_compact stub in test_engine_compaction.py declares client and compaction_model without type annotations, while every other stub for the same compact function in this PR (in test_agent_context.py, test_engine_client_lifecycle.py, test_main.py) explicitly types them as client: AsyncOpenAI and compaction_model: ModelConfig. This inconsistency means a signature change in the real compact function won't be caught by static analysis at this call site.

 

^{Triggered by learned rule: Use explicit typed parameters in test stubs, not **kwargs}

^{Reviewed by Cursor Bugbot for commit 44c492b. Configure here.}