Skip to content

The agent that grows with you

2.4 KB
Raw Blame
"""Grouping is advertised only when the delivery policy consumes it."""

import json
from dataclasses import fields

from tools.delegate_tool import DELEGATE_TASK_SCHEMA, _strip_model_hidden_task_fields
from tools.delegate_tool_dispatch import _Batch, _units_of
from tools.delegate_tool_tasks import _normalize_task_list
from tools.registry import registry


def test_group_schema_tracks_delivery_policy_without_mutating_previous_definitions(monkeypatch):
    from tools import delegate_tool_config

    original = json.dumps(DELEGATE_TASK_SCHEMA)
    snapshots = []
    for config in ({}, {"independent_completions": True}, {"independent_completions": False}):
        monkeypatch.setattr(delegate_tool_config, "_cfg", lambda: config)
        definition = registry.get_definitions({"delegate_task"})[0]
        enabled = config.get("independent_completions", False)
        task = definition["function"]["parameters"]["properties"]["tasks"]["items"]
        assert ("group" in task["properties"]) == enabled
        assert ("group" in definition["function"]["description"]) == enabled
        assert json.dumps(registry.get_definitions({"delegate_task"})[0]) == json.dumps(definition)
        for previous, serialized in snapshots:
            assert json.dumps(previous) == serialized
        snapshots.append((definition, json.dumps(definition)))
    assert json.dumps(DELEGATE_TASK_SCHEMA) == original


def test_legacy_group_replay_remains_accepted_and_delivery_policy_controls_units(monkeypatch):
    from tools import delegate_tool_config

    tasks = [{"goal": "Review first module", "group": "join"}, {"goal": "Review second module", "group": "join"}, {"goal": "Review third module"}]
    assert _strip_model_hidden_task_fields(tasks) is tasks
    normalized, error = _normalize_task_list(None, None, tasks, None, "leaf", 3)
    assert error is None and normalized == tasks
    batch = _Batch(**{field.name: None for field in fields(_Batch)})
    batch.children = [(i, task, None) for i, task in enumerate(tasks)]
    for enabled in (False, True):
        monkeypatch.setattr(delegate_tool_config, "_cfg", lambda: {"independent_completions": enabled})
        units = _units_of(batch)
        if enabled:
            assert [[i for i, _, _ in unit.children] for unit in units] == [[0, 1], [2]]
            assert [unit.group for unit in units] == ["join", None]
        else:
            assert units == [batch]