[aroshanghias-nvd]

The native compaction agent returns ordinary accepted rollout history and uses shared capture, allowing NeMo-RL to determine training segments. Semantic history, recency policies, guards, and the context client move into the optional nemo_gym.context_management package, and the agent shares termination semantics with simple_agent. The dedicated legacy compaction model/session are replaced by the ordinary vLLM model and context client, including removal of the associated ASR model entry.

Depends on shared infrastructure #4128, which should merge first. External harnesses that own compaction and NeMo-RL #4124 need the infrastructure layer; they do not need this optional native-agent migration.

Review scope: GitHub requires a base branch in the upstream repository, where this fork cannot create branches. This PR therefore remains based on main and its Files changed tab still includes #4128 until that PR merges. Review the agent-only diff for this layer. Once #4128 merges, update/rebase this PR so only the native-agent changes remain against main.

The original split preserved the entire source tree from head cf908566. Both layers are now rebased onto Gym main 366a9218; the agent commit remains patch-identical by git range-diff. Fresh upper-layer tests passed 95 cases on Mac, and pre-commit run --all-files passed on both layers. The rebased lower layer passed 1,761 Mac CPU cases. No dependency or lockfile changes are included. The lower-only infrastructure run independently passed two optimizer steps and exact capture/media audits with the compaction client package absent (W&B, maximum TMPE 1.000021). The GPU evidence predates this latest rebase and has not been rerun. Repository CI remains required before merge.

Previously documented combined-stack validation

The evidence below predates this source-preserving split. The new lower-only check is a two-step integration check, not a repeat of these 20-optimizer-step runs.

• 727 affected Gym tests passed after the main merge; pre-commit run --all-files passed.
• 152 paired RL compatibility/historical-consumer/exporter tests and 165 native capture/media/template tests passed; native tests had no skips. Startup using the actual TQ reassembler passed.
• Four scripted 20-turn before/after cases (compaction on/off, rejected attempts on/off) preserved requests, parent hints, accepted outputs, histories, and policy records.
• The paired live runs below each completed 20 optimizer steps and 40 rollouts. Saved-evidence audits verified exact training tokens, masks, rollout logprobs, rewards, and accepted-call membership; every selected generation was trained exactly once. The manufactured image run also verified image tensors and retained-image counts.

Run	Training rows	Selected calls
Manufactured, no compaction	40	800
Manufactured, image K2	400	800
Custom OpenCode, identity	40	850
Custom OpenCode, compaction	120	880

Qualification used paired source in a private aligned runtime (Ray 2.58.0, vLLM 0.29.0), not final CI against a merged dependency. The custom fork used a disclosed temporary collector ordering correction and a bounded tool task; stock OpenCode and SWE-bench are not qualified.

The fork's overlapping title/agent calls encountered transient admission refusals and retried successfully. All 80 final ledgers had zero pending/failed calls. Two Mac CPU ASGI reproductions confirmed that the rejected overlap never starts generation or poisons the ledger. The sequential guard is retained; arbitrary concurrent/branching capture remains unsupported by this qualification. The generic HTTP 500 and ambiguous pending-capture error text remain a diagnostic limitation.

The paired training TMPE investigation remains unresolved and deferred, with maximum OpenCode identity/compaction values of 1.0015546 / 1.0094431. Exact reconstruction does not prove numerical equivalence between generation and learner forward passes; no experimental router-padding changes are included.

[copy-pr-bot]

This pull request requires additional validation before any workflows can run on NVIDIA's runners.

Pull request vetters can view their responsibilities here.

Contributors can view more details about this message here.

[aroshanghias-nvd]

Please authorize the standard Gym CI for draft PR #3368 at 4870eb240475e078c4ea96af54ca2393298f4170. This updates the existing CC draft with the reviewed synthetic-digest baseline correction; the changed-file secrets scan passes locally. The paired RL PR is rebased onto merged #4191. Native/runtime qualification remains pending, and this PR remains a draft.

[aroshanghias-nvd]

@yaoyu-33 could you review this PR? In particular, should the compaction logic stay in simple_agent_with_compaction, or would it make sense to extract it into a shared library that other agents can reuse?

[JeffPengCoder]

@aroshanghias-nvd, following up on what I said in #3591: here are regression tests for the guard invariant on the new client. A view rejected by a context guard must never be sent to the model or become acknowledged history.

#3591 no longer touches the legacy ContextCompactionSession, so this invariant now lives only in this PR. The tests pass on 8cdaf672 (3 passed). Take, adapt or drop them as you see fit. They reach into a few private attributes (_completed_view_digest, _last_accepted_response_id, _step), so a public accessor may read better.

• A first action rejected by a guard is neither generated nor acknowledged, and the client closes.
• In turn-chunked mode, a rejection keeps only previously accepted history; the chunk record names the guard.
• Positive control: with a recency policy, the same guard admits after recompaction.

test_guard_invariant.py

# SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: Apache-2.0
"""A view rejected by a context guard is never sent to the model and never becomes acknowledged history."""

import json
from copy import deepcopy
from unittest.mock import AsyncMock, MagicMock

import pytest

from nemo_gym.config_types import ModelServerRef
from nemo_gym.context_management import ContextHistoryConfig, ContextManagedResponsesClient
from nemo_gym.context_management.client import ContextGuardRejected
from nemo_gym.openai_utils import NeMoGymResponse, NeMoGymResponseCreateParamsNonStreaming
from nemo_gym.server_utils import ServerClient


def answer(index):
    return NeMoGymResponse(
        id=f"response-{index}",
        created_at=0,
        error=None,
        incomplete_details=None,
        instructions=None,
        metadata=None,
        model="test",
        object="response",
        parallel_tool_calls=True,
        temperature=None,
        tool_choice="auto",
        tools=[],
        top_p=None,
        output=[
            {
                "id": f"message-{index}",
                "type": "message",
                "role": "assistant",
                "status": "completed",
                "content": [{"type": "output_text", "text": f"answer {index}", "annotations": []}],
            }
        ],
    )


def http_response(payload):
    response = MagicMock(ok=True, status=200, cookies={})
    response.read = AsyncMock(return_value=json.dumps(payload).encode())
    return response


def image_observation(name):
    return {
        "role": "user",
        "type": "message",
        "content": [
            {"type": "input_image", "image_url": f"https://example.invalid/{name}.png", "detail": "auto"},
            {"type": "input_text", "text": f"observation {name}"},
        ],
    }


def make_client(config, initial_input="task"):
    transport = MagicMock(spec=ServerClient)
    queue = [answer(index) for index in range(1, 20)]
    calls = []

    async def post(**kwargs):
        calls.append(deepcopy(kwargs))
        if kwargs["url_path"].endswith("/measure"):
            return http_response({"prompt_token_count": 10})
        return http_response(queue.pop(0).model_dump(mode="json"))

    transport.post = AsyncMock(side_effect=post)
    client = ContextManagedResponsesClient(
        server_client=transport,
        model_server=ModelServerRef(name="policy", type="responses_api_models"),
        logical_rollout_id="guard_g0",
        config=config,
        initial_request=NeMoGymResponseCreateParamsNonStreaming(input=initial_input, max_output_tokens=8),
    )
    return client, calls


def generation_calls(calls):
    return [call for call in calls if call["url_path"].endswith("/v1/responses")]


async def test_first_action_rejected_by_guard_is_never_generated_or_acknowledged():
    # Same scenario as #3591's legacy regression: an image in the initial context, no images allowed.
    config = ContextHistoryConfig.model_validate({"enabled": True, "guards": {"max_active_images": 0}})
    client, calls = make_client(config, initial_input=[image_observation("initial")])
    events_before = len(client.history.events)

    with pytest.raises(ContextGuardRejected):
        await client.create()

    assert generation_calls(calls) == []
    assert client.controller._completed_view_digest is None
    assert client._last_accepted_response_id is None
    assert client._step == 1
    assert len(client.history.events) == events_before
    with pytest.raises(RuntimeError, match="closed"):
        await client.create()
    with pytest.raises(RuntimeError, match="closed"):
        client.finish(answer(1))


async def test_chunked_guard_rejection_keeps_only_previously_accepted_history():
    config = ContextHistoryConfig.model_validate(
        {
            "enabled": True,
            "schedule": {"type": "turn_chunked_recency", "actions_per_chunk": 3},
            "guards": {"max_active_images": 1},
        }
    )
    client, calls = make_client(config)
    first = await client.create()
    client.append_observation([image_observation("a")])
    second = await client.create()
    accepted_digest = client.controller._completed_view_digest
    events_before = len(client.history.events)
    client.append_observation([image_observation("b")])
    events_with_observation = len(client.history.events)

    # Identity policy keeps both images, so closing the chunk cannot satisfy the guard.
    with pytest.raises(ContextGuardRejected):
        await client.create()

    assert len(generation_calls(calls)) == 2
    assert client._last_accepted_response_id == second.id
    assert client.controller._completed_view_digest == accepted_digest
    assert events_with_observation == events_before + 1
    assert len(client.history.events) == events_with_observation
    records = client.controller.chunk_records
    assert len(records) == 1
    assert records[0].eligible_action_ids == (first.id, second.id)
    assert records[0].early_close_reason == "guard:active_images"
    with pytest.raises(RuntimeError, match="closed"):
        await client.create()


async def test_chunked_guard_admits_after_recompaction_positive_control():
    config = ContextHistoryConfig.model_validate(
        {
            "enabled": True,
            "policy": {"type": "recency", "config": {"images": {"enabled": True, "keep_last_groups": 1}}},
            "schedule": {"type": "turn_chunked_recency", "actions_per_chunk": 3},
            "guards": {"max_active_images": 1},
        }
    )
    client, calls = make_client(config)
    await client.create()
    client.append_observation([image_observation("a")])
    await client.create()
    client.append_observation([image_observation("b")])
    third = await client.create()

    assert len(generation_calls(calls)) == 3
    assert client._last_accepted_response_id == third.id
    assert client.controller.chunk_records[0].early_close_reason == "guard:active_images"

[aroshanghias-nvd]

/ok to test 4d72925