codeplain 0.3.11.dev21__tar.gz → 0.3.12.dev23__tar.gz

{codeplain-0.3.11.dev21 → codeplain-0.3.12.dev23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: codeplain
-Version: 0.3.11.dev21
+Version: 0.3.12.dev23
 Summary: Transform plain language specifications into working code
 License-File: LICENSE
 Classifier: Environment :: Console

{codeplain-0.3.11.dev21 → codeplain-0.3.12.dev23}/codeplain_REST_api.py

@@ -1,8 +1,11 @@
+import socket
 import time
 from typing import Optional
 
 import requests
+from requests.adapters import HTTPAdapter
 from requests.exceptions import ConnectionError, RequestException, Timeout
+from urllib3.connection import HTTPConnection
 
 import plain2code_exceptions
 from plain2code_console import RETRY_COLOR
@@ -15,6 +18,57 @@ RETRY_DELAY = 3
 # at exit, and requests waits indefinitely by default.
 REPORT_TIMEOUT_SECONDS = 5
 
+# A render call can leave the connection with nothing on it for several minutes while the
+# service works on the answer. Network equipment between the two, such as the address
+# translation a CI runner sits behind, drops a connection that quiet and tells neither end.
+# The answer then has nowhere to go and the client waits for it for as long as it is allowed
+# to run. These probes put a packet on the connection often enough to keep it, and they end
+# it when the other end has really gone.
+KEEPALIVE_IDLE_SECONDS = 60
+KEEPALIVE_INTERVAL_SECONDS = 30
+KEEPALIVE_FAILED_PROBES = 4
+
+
+def keepalive_socket_options():
+    """The socket options that keep a long, quiet request alive, for the platforms that have them."""
+    options = list(HTTPConnection.default_socket_options)
+    options.append((socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1))
+    # The option that sets the idle time is named differently per platform, and Windows has
+    # none of the three. Whatever is missing is left out; the keepalive itself still applies.
+    for idle_option in ("TCP_KEEPIDLE", "TCP_KEEPALIVE"):
+        if hasattr(socket, idle_option):
+            options.append((socket.IPPROTO_TCP, getattr(socket, idle_option), KEEPALIVE_IDLE_SECONDS))
+            break
+    if hasattr(socket, "TCP_KEEPINTVL"):
+        options.append((socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, KEEPALIVE_INTERVAL_SECONDS))
+    if hasattr(socket, "TCP_KEEPCNT"):
+        options.append((socket.IPPROTO_TCP, socket.TCP_KEEPCNT, KEEPALIVE_FAILED_PROBES))
+    return options
+
+
+class KeepaliveAdapter(HTTPAdapter):
+    """Opens every connection with keepalive on, whether it goes direct or through a proxy."""
+
+    def init_poolmanager(self, *args, **kwargs):
+        kwargs["socket_options"] = keepalive_socket_options()
+        return super().init_poolmanager(*args, **kwargs)
+
+    def proxy_manager_for(self, proxy, **proxy_kwargs):
+        # A request that goes through a proxy is served from a separate pool, which the
+        # options above never reach. A render behind a proxy is as quiet as any other and
+        # needs the same keepalive.
+        proxy_kwargs["socket_options"] = keepalive_socket_options()
+        return super().proxy_manager_for(proxy, **proxy_kwargs)
+
+
+def new_session():
+    """A requests session whose connections carry keepalive."""
+    session = requests.Session()
+    session.mount("https://", KeepaliveAdapter())
+    session.mount("http://", KeepaliveAdapter())
+    return session
+
+
 RETRY_ERROR_CODES = [
     "LLMInternalError",
 ]
@@ -36,6 +90,7 @@ class CodeplainAPI:
     def __init__(self, api_key, console):
         self.api_key = api_key
         self.console = console
+        self.session = new_session()
 
     @property
     def api_url(self):
@@ -139,7 +194,7 @@ class CodeplainAPI:
 
         for attempt in range(num_retries + 1):
             try:
-                response = requests.post(endpoint_url, headers=headers, json=payload, timeout=timeout)
+                response = self.session.post(endpoint_url, headers=headers, json=payload, timeout=timeout)
 
                 try:
                     response_json = response.json()
@@ -253,6 +308,38 @@ class CodeplainAPI:
 
         return self.post_request(endpoint_url, headers, payload, run_state)
 
+    def fix_unittests_issue(
+        self,
+        frid,
+        plain_source_tree,
+        linked_resources,
+        existing_files_content,
+        module_name: str,
+        required_modules,
+        unittests_issue,
+        run_state: RunState,
+        conformance_tests_fixes: list[dict] | None = None,
+    ):
+        endpoint_url = f"{self.api_url}/fix_unittests_issue"
+        headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
+
+        payload = {
+            "frid": frid,
+            "plain_source_tree": plain_source_tree,
+            "linked_resources": linked_resources,
+            "existing_files_content": existing_files_content,
+            "module_name": module_name,
+            "required_modules": required_modules,
+            "unittests_issue": unittests_issue,
+            "unittest_batch_id": run_state.unittest_batch_id,
+        }
+        # Implementation code changes made by the conformance tests fixer right before this unit tests run;
+        # only sent when unit tests are processed inside the conformance tests phase.
+        if conformance_tests_fixes is not None:
+            payload["conformance_tests_fixes"] = conformance_tests_fixes
+
+        return self.post_request(endpoint_url, headers, payload, run_state)
+
     def distill_conformance_test_memory(
         self,
         frid,
@@ -526,29 +613,3 @@ class CodeplainAPI:
         }
 
         return self.post_request(endpoint_url, headers, payload, run_state)
-
-    def agent_start(self, task_type: str, task_params: dict, frid: str, module_name: str, run_state: RunState):
-        """Start a server-side agent session; returns the first turn (tool calls or completion)."""
-        endpoint_url = f"{self.api_url}/agent/start"
-        headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
-        payload = {
-            "task_type": task_type,
-            "task_params": task_params,
-            "frid": frid,
-            "module_name": module_name,
-        }
-        return self.post_request(endpoint_url, headers, payload, run_state)
-
-    def agent_continue(
-        self, session_id: str, tool_results: list[dict], frid: str, module_name: str, run_state: RunState
-    ):
-        """Feed tool results into an agent session and run its next turn."""
-        endpoint_url = f"{self.api_url}/agent/continue"
-        headers = {"X-API-Key": self.api_key, "Content-Type": "application/json"}
-        payload = {
-            "session_id": session_id,
-            "tool_results": tool_results,
-            "frid": frid,
-            "module_name": module_name,
-        }
-        return self.post_request(endpoint_url, headers, payload, run_state)

codeplain-0.3.12.dev23/render_machine/actions/fix_unit_tests.py

@@ -0,0 +1,79 @@
+from typing import Any
+
+import file_utils
+import render_machine.render_utils as render_utils
+from plain2code_console import console
+from plain2code_exceptions import InternalClientError
+from render_machine.actions.base_action import BaseAction
+from render_machine.implementation_code_helpers import ImplementationCodeHelpers
+from render_machine.render_context import RenderContext
+
+MAX_ISSUE_LENGTH = 10000
+
+
+class FixUnitTests(BaseAction):
+    SUCCESSFUL_OUTCOME = "unit_tests_fix_generated"
+
+    def execute(self, render_context: RenderContext, previous_action_payload: Any | None):
+        if not previous_action_payload.get("previous_unittests_issue"):
+            raise InternalClientError(
+                "Internal client error: Previous action payload does not contain previous unit tests issue."
+            )
+        previous_unittests_issue = previous_action_payload["previous_unittests_issue"]
+
+        if previous_unittests_issue and len(previous_unittests_issue) > MAX_ISSUE_LENGTH:
+            console.debug(
+                f"Unit tests issue text is too long and will be smartly truncated to {MAX_ISSUE_LENGTH} characters."
+            )
+
+        existing_files, existing_files_content = ImplementationCodeHelpers.fetch_existing_files(
+            render_context.build_folder
+        )
+
+        render_utils.print_inputs(render_context, existing_files_content, "Files sent as input to unit tests fixing:")
+
+        conformance_tests_fixes = self._get_conformance_tests_fixes(render_context)
+        if conformance_tests_fixes:
+            console.info(
+                f"Unit tests are fixed while preserving {len(conformance_tests_fixes)} implementation code change(s) "
+                "made to fix the conformance tests."
+            )
+
+        response_files = render_context.codeplain_api.fix_unittests_issue(
+            render_context.frid_context.frid,
+            render_context.plain_source_tree,
+            render_context.frid_context.linked_resources,
+            existing_files_content,
+            render_context.module_name,
+            render_context.get_required_modules_functionalities(),
+            previous_unittests_issue,
+            run_state=render_context.run_state,
+            conformance_tests_fixes=conformance_tests_fixes,
+        )
+
+        _, changed_files = file_utils.update_build_folder_with_rendered_files(
+            render_context.build_folder, existing_files, response_files
+        )
+
+        render_context.unit_tests_running_context.changed_files.update(changed_files)
+
+        console.print_files("Files fixed:", render_context.build_folder, response_files, style=console.OUTPUT_STYLE)
+
+        return self.SUCCESSFUL_OUTCOME, None
+
+    @staticmethod
+    def _get_conformance_tests_fixes(render_context: RenderContext) -> list[dict] | None:
+        """Implementation code changes the conformance tests fixer made before these unit tests were run.
+
+        Only present when unit tests are processed inside the conformance tests phase - the implementation
+        and refactoring unit test passes have no conformance tests running context.
+        """
+        conformance_tests_running_context = getattr(render_context, "conformance_tests_running_context", None)
+        if conformance_tests_running_context is None:
+            return None
+
+        implementation_code_fixes = getattr(conformance_tests_running_context, "implementation_code_fixes", None)
+        if not implementation_code_fixes:
+            return None
+
+        return list(implementation_code_fixes)

{codeplain-0.3.11.dev21 → codeplain-0.3.12.dev23}/render_machine/actions/run_unit_tests.py

@@ -16,15 +16,6 @@ class RunUnitTests(BaseAction):
     UNRECOVERABLE_ERROR_OUTCOME = "unrecoverable_error_occurred"
 
     def execute(self, render_context: RenderContext, _previous_action_payload: Any | None):
-        context = render_context.unit_tests_running_context
-        if context.verified_passing:
-            # The fixing agent's own run passed and no file changed since; running again is redundant.
-            context.verified_passing = False
-            console.info("Unit tests already passed in the fixing agent's last run; not running them again.")
-            render_context.script_execution_history.latest_unit_test_output_path = context.verified_passing_log_path
-            render_context.script_execution_history.should_update_script_outputs = True
-            return self.SUCCESSFUL_OUTCOME, None
-
         unittests_script = os.path.normpath(render_context.unittests_script)
 
         console.info(

{codeplain-0.3.11.dev21 → codeplain-0.3.12.dev23}/render_machine/render_context.py

@@ -19,7 +19,6 @@ from render_machine.render_types import (
     FridContext,
     ScriptExecutionHistory,
     TestExecutionPhase,
-    UnitTestsAgentSession,
     UnitTestsRunningContext,
 )
 
@@ -189,14 +188,6 @@ class RenderContext:
     def should_run_conformance_tests(self) -> bool:
         return self.conformance_tests_script is not None
 
-    @property
-    def unit_tests_agent_session(self) -> UnitTestsAgentSession:
-        """The agent session fixing the unit tests: per unit-test loop, except during the conformance
-        phase, where one session spans every loop (see UnitTestsAgentSession)."""
-        if self.conformance_tests_running_context is not None:
-            return self.conformance_tests_running_context.unit_tests_agent_session
-        return self.unit_tests_running_context.agent_session
-
     def start_unittests_processing(self):
         self.unit_tests_running_context = UnitTestsRunningContext(fix_attempts=0)
         self.run_state.increment_unittest_batch_id()

{codeplain-0.3.11.dev21 → codeplain-0.3.12.dev23}/render_machine/render_types.py

@@ -48,53 +48,10 @@ class FridContext:
     refactoring_iteration: int = 0
 
 
-@dataclass
-class UnitTestsAgentSession:
-    """Server-side agent session fixing a FRID's unit tests, and what it still has to be told.
-
-    Owned by the unit-tests running context (one session per unit-test loop) in the implementation
-    and refactoring phases, and by the conformance tests running context during the conformance
-    phase, so there one session spans every unit-test loop - the agent then sees that the
-    conformance tests fixer keeps changing the code it adjusts (see RenderContext.unit_tests_agent_session).
-    """
-
-    session_id: Optional[str] = None
-    # The submit_fix call the agent ended its last attempt with, answered with the next test
-    # run's outcome, plus results of any tool calls made in the same turn as submit_fix.
-    pending_submit_call_id: Optional[str] = None
-    pending_tool_results: list[dict] = field(default_factory=list)
-    # Session abandoned without a submission (turn budget used up, LLM failure); the next session
-    # starts with a digest of what it tried.
-    previous_session_id: Optional[str] = None
-    # Full test logs the agent was pointed to; readable by read_file/grep although outside the
-    # build folder.
-    readable_log_paths: set[str] = field(default_factory=set)
-    # How many of the conformance tests fixes (ConformanceTestsRunningContext.implementation_code_fixes)
-    # the session has already been shown.
-    conformance_fixes_handed_off: int = 0
-
-    def reset(self) -> None:
-        """Drop the session (keeping its id as the previous one) so the next failure starts a new one."""
-        self.previous_session_id = self.session_id
-        self.session_id, self.pending_submit_call_id, self.pending_tool_results = None, None, []
-        self.conformance_fixes_handed_off = 0
-
-
 @dataclass
 class UnitTestsRunningContext:
     fix_attempts: int
     changed_files: set[str] = field(default_factory=set)
-    # The agent session of this loop; used only outside the conformance phase.
-    agent_session: UnitTestsAgentSession = field(default_factory=UnitTestsAgentSession)
-    # Whether the agent already made a fix attempt in this loop. A session that is still open when
-    # a loop starts had its last fix accepted, which is what the agent is told.
-    agent_used_in_this_loop: bool = False
-    # Set when the agent's own run_unit_tests passed and no file changed since, so the harness
-    # can accept the fix without running the suite again.
-    verified_passing: bool = False
-    verified_passing_log_path: Optional[str] = None
-    # Results of read-only tool calls, keyed by call; cleared whenever a file changes.
-    tool_result_cache: dict[str, str] = field(default_factory=dict)
 
 
 class ConformanceTestsRunningContext:
@@ -138,8 +95,6 @@ class ConformanceTestsRunningContext:
         # order. Each entry is {"hypothesis": str | None, "approach": str | None, "code_diff": {file: diff}}.
         # Handed to the unit tests fixer so it adjusts the unit tests instead of reverting these changes.
         self.implementation_code_fixes: list[dict] = []
-        # The unit-test fixing agent session, shared by every unit-test loop of this conformance phase.
-        self.unit_tests_agent_session = UnitTestsAgentSession()
 
     def get_conformance_tests_json(self, module_name: str) -> dict:
         return self._conformance_tests_json[module_name]

{codeplain-0.3.11.dev21 → codeplain-0.3.12.dev23}/tests/test_fix_unit_tests_conformance_context.py

@@ -12,44 +12,25 @@ import pytest
 
 import plain_spec
 from memory_management import MemoryManager
+from render_machine.actions import fix_unit_tests as fix_unit_tests_module
 from render_machine.actions.fix_conformance_test import FixConformanceTest
 from render_machine.actions.fix_unit_tests import FixUnitTests
 from render_machine.implementation_code_helpers import ImplementationCodeHelpers
-from render_machine.render_context import RenderContext
-from render_machine.render_types import ConformanceTestsRunningContext, ScriptExecutionHistory, UnitTestsRunningContext
+from render_machine.render_types import ConformanceTestsRunningContext, UnitTestsRunningContext
 
 
 class FakeCodeplainAPI:
-    """Conformance fixes return a scripted response; every agent session submits a fix on its first turn."""
-
-    def __init__(self, conformance_fix_response=None):
+    def __init__(self, conformance_fix_response=None, unittests_fix_response=None):
         self.conformance_fix_response = conformance_fix_response
-        self.agent_calls = []
-        self.sessions_started = 0
+        self.unittests_fix_response = unittests_fix_response or {}
+        self.unittests_fix_calls = []
 
     def fix_conformance_tests_issue(self, *args, **kwargs):
         return self.conformance_fix_response
 
-    def agent_start(self, task_type, task_params, frid, module_name, run_state):
-        self.sessions_started += 1
-        self.agent_calls.append(("start", task_params))
-        return self._submit(f"s{self.sessions_started}")
-
-    def agent_continue(self, session_id, tool_results, frid, module_name, run_state):
-        self.agent_calls.append(("continue", session_id, tool_results))
-        return self._submit(session_id)
-
-    def _submit(self, session_id):
-        call_id = f"submit-{len(self.agent_calls)}"
-        return {
-            "session_id": session_id,
-            "status": "tool_calls",
-            "calls": [{"id": call_id, "name": "submit_fix", "args": {"changes_made": "fixed"}}],
-        }
-
-
-class FakeRenderContext(SimpleNamespace):
-    unit_tests_agent_session = RenderContext.unit_tests_agent_session
+    def fix_unittests_issue(self, *args, **kwargs):
+        self.unittests_fix_calls.append(kwargs)
+        return self.unittests_fix_response
 
 
 class FakeConformanceTests:
@@ -78,11 +59,7 @@ def memory_folder():
 def isolate_from_git_and_console(monkeypatch):
     monkeypatch.setattr(ImplementationCodeHelpers, "get_code_diff", staticmethod(lambda *args: {}))
     monkeypatch.setattr(plain_spec, "collect_linked_resources", lambda *args: None)
-    monkeypatch.setattr(
-        plain_spec,
-        "get_specifications_for_frid",
-        lambda tree, frid: ({plain_spec.FUNCTIONAL_REQUIREMENTS: ["- Add numbers."]}, None),
-    )
+    monkeypatch.setattr(fix_unit_tests_module.render_utils, "print_inputs", lambda *args: None)
 
 
 def make_conformance_context():
@@ -99,7 +76,7 @@ def make_conformance_context():
 
 
 def make_render_context(api, build_folder, memory_folder, conformance_tests_running_context):
-    return FakeRenderContext(
+    return SimpleNamespace(
         codeplain_api=api,
         build_folder=build_folder,
         memory_manager=MemoryManager(api, memory_folder),
@@ -109,11 +86,9 @@ def make_render_context(api, build_folder, memory_folder, conformance_tests_runn
         plain_source_tree={},
         module_name="mod",
         required_modules=None,
-        frid_context=SimpleNamespace(frid="1", linked_resources={}, changed_files=set()),
+        frid_context=SimpleNamespace(frid="1", linked_resources={}),
         get_required_modules_functionalities=lambda: {},
         run_state=SimpleNamespace(render_id="test-render-id", unittest_batch_id=1),
-        unittests_script=None,
-        script_execution_history=ScriptExecutionHistory(),
     )
 
 
@@ -216,104 +191,34 @@ def test_implementation_fix_with_no_files_is_not_remembered(build_folder, memory
     assert ctx.implementation_code_fixes == []
 
 
-def run_unit_tests_fix(render_context, issue="1 failed"):
-    return FixUnitTests().execute(render_context, {"previous_unittests_issue": issue})
-
-
-def start_new_unit_test_loop(render_context):
-    """What RenderContext.start_unittests_processing does when the unit tests are run again."""
-    render_context.unit_tests_running_context = UnitTestsRunningContext(fix_attempts=0)
-
-
-def conformance_fix(number):
-    return {
-        "hypothesis": f"hypothesis {number}",
-        "approach": f"approach {number}",
-        "code_diff": {"app.py": f"+{number}"},
-    }
+def run_unit_tests_fix(render_context):
+    return FixUnitTests().execute(render_context, {"previous_unittests_issue": "1 failed"})
 
 
-def test_first_unit_test_loop_of_conformance_phase_seeds_the_session_with_the_fixes(build_folder, memory_folder):
-    api = FakeCodeplainAPI()
+def test_unit_tests_fix_forwards_conformance_fixes(build_folder, memory_folder):
+    api = FakeCodeplainAPI(unittests_fix_response={"test_app.py": "def test_add(): pass\n"})
     ctx = make_conformance_context()
-    ctx.implementation_code_fixes.append(conformance_fix(1))
+    ctx.implementation_code_fixes.append(
+        {"hypothesis": "off by one", "approach": "add one", "code_diff": {"app.py": "+    return a + b + 1"}}
+    )
     render_context = make_render_context(api, build_folder, memory_folder, ctx)
 
     outcome, _ = run_unit_tests_fix(render_context)
 
     assert outcome == FixUnitTests.SUCCESSFUL_OUTCOME
-    kind, task_params = api.agent_calls[0]
-    assert kind == "start"
-    assert task_params["conformance_tests_fixes"] == ctx.implementation_code_fixes
+    assert len(api.unittests_fix_calls) == 1
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] == ctx.implementation_code_fixes
     # The forwarded list is a copy, so later conformance fixes do not mutate what was sent.
-    assert task_params["conformance_tests_fixes"] is not ctx.implementation_code_fixes
-    # The file the conformance fix changed is seeded although the FRID did not change it.
-    assert "app.py" in task_params["relevant_files"]
-    assert ctx.unit_tests_agent_session.session_id == "s1"
-
-
-def test_next_unit_test_loop_of_conformance_phase_continues_the_session_with_only_new_fixes(
-    build_folder, memory_folder
-):
-    api = FakeCodeplainAPI()
-    ctx = make_conformance_context()
-    ctx.implementation_code_fixes.append(conformance_fix(1))
-    render_context = make_render_context(api, build_folder, memory_folder, ctx)
-    run_unit_tests_fix(render_context)
-
-    # The fix was accepted; the conformance tests fixer changes the code again and the unit tests fail again.
-    ctx.implementation_code_fixes.append(conformance_fix(2))
-    start_new_unit_test_loop(render_context)
-    run_unit_tests_fix(render_context, issue="2 failed")
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] is not ctx.implementation_code_fixes
 
-    assert api.sessions_started == 1
-    kind, session_id, tool_results = api.agent_calls[1]
-    assert (kind, session_id) == ("continue", "s1")
-    submit_answer = tool_results[-1]
-    assert submit_answer["call_id"] == "submit-1"
-    assert submit_answer["output"].startswith("Your fix was accepted: the unit tests passed.")
-    assert "Conformance Tests Fix below" in submit_answer["output"]
-    assert submit_answer["conformance_tests_fixes"] == [conformance_fix(2)]
-    assert submit_answer["test_output"] == "2 failed"
 
-
-def test_retry_within_a_unit_test_loop_says_the_fix_did_not_work(build_folder, memory_folder):
-    api = FakeCodeplainAPI()
-    ctx = make_conformance_context()
-    ctx.implementation_code_fixes.append(conformance_fix(1))
-    render_context = make_render_context(api, build_folder, memory_folder, ctx)
-    run_unit_tests_fix(render_context)
-
-    run_unit_tests_fix(render_context, issue="still failing")
-
-    submit_answer = api.agent_calls[1][2][-1]
-    assert "still fail" in submit_answer["output"]
-    # Fix 1 was already shown to the session, so it is not sent again.
-    assert "conformance_tests_fixes" not in submit_answer
-
-
-def test_new_conformance_phase_starts_a_new_session(build_folder, memory_folder):
-    api = FakeCodeplainAPI()
-    render_context = make_render_context(api, build_folder, memory_folder, make_conformance_context())
-    run_unit_tests_fix(render_context)
-
-    # E.g. the functionality is re-rendered from scratch: the conformance tests running context is recreated.
-    render_context.conformance_tests_running_context = make_conformance_context()
-    start_new_unit_test_loop(render_context)
-    run_unit_tests_fix(render_context)
-
-    assert [call[0] for call in api.agent_calls] == ["start", "start"]
-
-
-def test_unit_tests_outside_conformance_phase_get_no_fixes_and_a_session_per_loop(build_folder, memory_folder):
+def test_unit_tests_fix_outside_conformance_phase_sends_no_fixes(build_folder, memory_folder):
     api = FakeCodeplainAPI()
     render_context = make_render_context(api, build_folder, memory_folder, None)
-    run_unit_tests_fix(render_context)
-    start_new_unit_test_loop(render_context)
+
     run_unit_tests_fix(render_context)
 
-    assert [call[0] for call in api.agent_calls] == ["start", "start"]
-    assert all("conformance_tests_fixes" not in call[1] for call in api.agent_calls)
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] is None
 
 
 def test_unit_tests_fix_in_conformance_phase_without_implementation_changes_sends_no_fixes(build_folder, memory_folder):
@@ -322,4 +227,4 @@ def test_unit_tests_fix_in_conformance_phase_without_implementation_changes_send
 
     run_unit_tests_fix(render_context)
 
-    assert "conformance_tests_fixes" not in api.agent_calls[0][1]
+    assert api.unittests_fix_calls[0]["conformance_tests_fixes"] is None