codeplain 0.3.11.dev21__py3-none-any.whl → 0.3.12.dev23__py3-none-any.whl

{codeplain-0.3.11.dev21.dist-info → codeplain-0.3.12.dev23.dist-info}/METADATA

@@ -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.dist-info → codeplain-0.3.12.dev23.dist-info}/RECORD

@@ -1,5 +1,5 @@
 change_detection.py,sha256=CazORZrezeZSw2I6VBvieN-c2SEjieZPo6pNrKwmMVA,6915
-codeplain_REST_api.py,sha256=EsKbrbwSxACoN62NNz8AukUgKZvg-YGOpv5aP8ZxF_E,22645
+codeplain_REST_api.py,sha256=RGCoPyxzzdshJW96UDmwKjtgMk11iSyIK4iiHMdFIW8,25332
 concept_utils.py,sha256=TpyiQ4DfMtO231j-lPj65i0suRTPr8t9j3QNf9KiM4A,8080
 conformance_fix_journal.py,sha256=7wL3UOc3BWaUo5MCmiFbb3kIwOQ6iEpdQSyEmedo8Vk,9488
 diff_utils.py,sha256=AjiQlqo5pRos_8hVXZo5yBurl5BzSrTMGrQv4dCtRCg,1198
@@ -37,12 +37,11 @@ config/system_config.yaml,sha256=of5R9vukSohU9AlkGJOcAVQA1UJgxYmDy6islU6iFuE,508
 docs/generate_cli.py,sha256=0FHVhICbM8g7ahdInTNih3hNKpty1wbV5rdGECMJj48,656
 examples/example_hello_world_python/harness_tests/hello_world_display/test_hello_world.py,sha256=dwTowrHiVKKbrDv21v8xJC30Q57AXZkQasdGOO5JsBE,470
 render_machine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-render_machine/agent_tools.py,sha256=Kp2g9GphV7oA9MbOHctKp0UJJJUOgcfCz2SeW9NL6jg,12305
 render_machine/code_renderer.py,sha256=-vp_ltU7e3ssX9hbS8IY4ETSp-39JAuoJ3ZltKpdt1M,3959
 render_machine/conformance_tests.py,sha256=PNTCnJNd_xNIhpTPPS8vlx8qws3cTgQSTLdADRab2YM,9617
 render_machine/implementation_code_helpers.py,sha256=Fxm-IInoZjAIZn41_-WXWj7VIYczpW4yH44Gt8CYMAQ,2378
-render_machine/render_context.py,sha256=Jo6eRYPYw5YxNLz2nhkS3-W_hYSPlhu5QEyIE-zJTaM,26812
-render_machine/render_types.py,sha256=54A0O8IrKx9HGMAlBfiCnmVLcmacBbX0qo_qqXO3_YU,11572
+render_machine/render_context.py,sha256=iaJWI_EMSn51LNF_b7KRvlir46ZgUkjbaEiVgSvMTCI,26314
+render_machine/render_types.py,sha256=A5BHAkjmDHQ0pd5rR6THlRY5z6rzrdJdcgZFhN7yw9w,8860
 render_machine/render_utils.py,sha256=yA3X15E_Lebk_-MxkSz9rM_qy-Pes8EQ9Ye-smkHCDw,9320
 render_machine/state_machine_config.py,sha256=0pL4PyrZ5F2UumvHLMRfhyh64M4pDvf-9zEs-5OAEU8,27866
 render_machine/states.py,sha256=Lu-7upbs9_bjJsy0P738qx5IiN0DzVcFdhF2-m6YjnQ,2067
@@ -56,14 +55,14 @@ render_machine/actions/distill_conformance_test_memory.py,sha256=ENjfhTWqRLePHeR
 render_machine/actions/exit_with_error.py,sha256=W6TMULHJcHEaXE4WUnlELEu0_l7IZy9HWaPkXyqg7ck,1279
 render_machine/actions/finish_functional_requirement.py,sha256=usQgPSg6PHpBOR1RhK7lPz9zjY-2VJJDqi3T0nlqdLw,841
 render_machine/actions/fix_conformance_test.py,sha256=Yy6niLefPIyR3vSxyyX4NUi3NJ4dVc0aEAH9JBCBYX4,11572
-render_machine/actions/fix_unit_tests.py,sha256=NgfoqCI4XANrA9muAT9bygEEuvqnwTTZGJS4nfsy0WM,13540
+render_machine/actions/fix_unit_tests.py,sha256=pqZzp7snSAe967o_kbh1yAhp9pZIMFY9uoJK1HGcCuc,3532
 render_machine/actions/prepare_repositories.py,sha256=HyZ1R6E3H5V-G4WDSGfhxl_arskmW9FcaxNdQr6JjVs,3867
 render_machine/actions/prepare_testing_environment.py,sha256=kIsXgV6-jOlqp-04cimPgTQoHPrVIu0zW-H_Jj-jowE,2106
 render_machine/actions/refactor_code.py,sha256=gyPsnqgHseL2bkENu4WeGCRyV0R18_GH3JOrPdoxKvg,2609
 render_machine/actions/render_conformance_tests.py,sha256=5gOQn-G1T9UWEI8sDfALcVdArk0ln9DgUprOPjccS-U,9268
 render_machine/actions/render_functional_requirement.py,sha256=53KzMVlcefoag1x73roCEQvQ7FbmH8FzhXMQau-s8tg,4655
 render_machine/actions/run_conformance_tests.py,sha256=yUG6buqp75EOmJYxdM6MmCNF5_G4TUxA-QSTKx7EzxA,3760
-render_machine/actions/run_unit_tests.py,sha256=j0qsHMLy49I_DX5QLlH0OdPT6bPMc0icmVg2N5MYm9U,2711
+render_machine/actions/run_unit_tests.py,sha256=A4WXtSzpCLDHYR8fQAbfxUf_E19GYflZSHZaSreoFPk,2101
 render_machine/actions/summarize_conformance_tests.py,sha256=Vy1kRK8vyazK_BbsKuz1MLDN_TQWVxxzkwEEm-50byc,1639
 standard_template_library/golang-console-app-template.plain,sha256=JOusEjCj7jagnXUzaI-SdIr3hj1wTo2uShK017aNtVM,949
 standard_template_library/python-console-app-template.plain,sha256=HW-REeF8Crk0r_w4-MxnleVHeW6PdOB2C8gO8FDG61g,931
@@ -71,7 +70,6 @@ standard_template_library/typescript-react-app-boilerplate.plain,sha256=6LFxhEOz
 standard_template_library/typescript-react-app-template.plain,sha256=DN5wEJcT8ZqQTf0vFKi9Z1isi9cin2UVNOZb3r28d3M,715
 tests/__init__.py,sha256=Wk73Io62J15BtlLVIzxmASDWaaJkQLevS4BLK5LDAQg,16
 tests/conftest.py,sha256=QZcp08htUlJGgmHDlRWFgsWXZ8o8IBWTD5QqJaUMlU8,790
-tests/test_agent_tools.py,sha256=1WQjKlDd1kna5D4fvlLJ1o5DxyjW0wy-9tx8tRPv6Sw,7840
 tests/test_arg_provenance.py,sha256=d_J7aCeHMXBpctBWTt60WU-I8pEKN7XRXRTJZZGCdo0,3441
 tests/test_change_detection.py,sha256=jH8SEhndX400DNqIKmcYLzxHqq9WFdgmuvY3XPq-ZFc,13534
 tests/test_cli_output.py,sha256=9yTk0pD2w6vkiSdSkYwneUmEtNqX4x64F6PzYShUEcw,19331
@@ -80,8 +78,7 @@ tests/test_console_log_styles.py,sha256=sxlhynMAP-kmqhBn1-pKvZXdCnlKSyCGJqwYKrh6
 tests/test_distill_conformance_test_memory.py,sha256=Tftw9l-gLVwIU6QttY03h2VedvuFxpIsCmZIzvWfxMA,5481
 tests/test_dry_run_link_validation.py,sha256=ivvYXQPqUkQ8glbFyUrdCninCxF2mg-rAsDcfjcB7MM,2140
 tests/test_file_utils.py,sha256=R_ZIhrTtwlhHxgmbBtA8PFEU5-QB4Fi5skJ7PS2KzdU,3614
-tests/test_fix_unit_tests_action.py,sha256=0xY94BFbYa528LBXmO7_gfVNbQEqdzXsDHPjQV5qfy0,11410
-tests/test_fix_unit_tests_conformance_context.py,sha256=G6-_YMhN5BY1sJ7cAx3BDnf_McgFcRpyP0iP6mwJ1eA,13154
+tests/test_fix_unit_tests_conformance_context.py,sha256=IEsXK0xMLRuHmoQGBwrY0ENWVng2n-db_YzSO2qBfqM,9136
 tests/test_folder_path_resolution.py,sha256=K9v684xkPE0HOAsovg8uDixpZmaIk7ho-Wd3rTjKLF0,6560
 tests/test_git_preflight.py,sha256=6aQqInDzpk03pS-6UfkGQWjErrIXTEdHs5oeq3ZYzTw,3186
 tests/test_git_utils.py,sha256=h3rWhhs4XVRYqzVzdmj51siF_AYD-GkbZiefK2iGfWo,15614
@@ -120,8 +117,8 @@ tui/spinner.py,sha256=Ro6Gd9Przf-whuHqPRY6HwI0T57yJjyNPbhDbigZKZE,2471
 tui/state_handlers.py,sha256=zbUS_D9eU8qIwVpaxPEp9zL9bpg8gXsWNoUaqg9TLrQ,16664
 tui/styles.css,sha256=kiC7Og_2G1E7owoiZgV95-3_dSeQnsNj3qzaY04xkDg,6727
 tui/widget_helpers.py,sha256=jitm2WHiKj-NVFL-hULxWzckPreRbUTl9OIZLN31-ek,6997
-codeplain-0.3.11.dev21.dist-info/METADATA,sha256=13HswQFYWExr96sPoJRzhzNlaHMus3rutS_9Ba8Z13Y,7257
-codeplain-0.3.11.dev21.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-codeplain-0.3.11.dev21.dist-info/entry_points.txt,sha256=oDZkBqu9WhtZApb_K6ia8-fn9aojwmAsgnKELceX5T4,46
-codeplain-0.3.11.dev21.dist-info/licenses/LICENSE,sha256=pCeKgQ1mXE5OmNUuKOfOZh1T1vqkeCUxghE7N8qgnzc,11345
-codeplain-0.3.11.dev21.dist-info/RECORD,,
+codeplain-0.3.12.dev23.dist-info/METADATA,sha256=l_JE3UfPJT-Mwf0iCcx_uzEX_wFthjf6kF-K6htwRSo,7257
+codeplain-0.3.12.dev23.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+codeplain-0.3.12.dev23.dist-info/entry_points.txt,sha256=oDZkBqu9WhtZApb_K6ia8-fn9aojwmAsgnKELceX5T4,46
+codeplain-0.3.12.dev23.dist-info/licenses/LICENSE,sha256=pCeKgQ1mXE5OmNUuKOfOZh1T1vqkeCUxghE7N8qgnzc,11345
+codeplain-0.3.12.dev23.dist-info/RECORD,,

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)

render_machine/actions/fix_unit_tests.py

@@ -1,256 +1,79 @@
-import os
-from http import HTTPStatus
 from typing import Any
 
-import requests
-
 import file_utils
-import plain_spec
+import render_machine.render_utils as render_utils
 from plain2code_console import console
 from plain2code_exceptions import InternalClientError
-from render_machine import agent_tools
 from render_machine.actions.base_action import BaseAction
+from render_machine.implementation_code_helpers import ImplementationCodeHelpers
 from render_machine.render_context import RenderContext
 
-TASK_TYPE = "fix_unit_tests"
-SUBMIT_FIX_TOOL = "submit_fix"
-# Upper bound on LLM turns spent on one fix attempt; the server bounds the whole session.
-MAX_AGENT_TURNS_PER_ATTEMPT = 40
-# Answer to a submit_fix whose fix was accepted in an earlier unit-test loop of the conformance phase.
-ACCEPTED_THEN_CHANGED_MESSAGE = (
-    "Your fix was accepted: the unit tests passed. Afterwards the implementation code was changed to fix the "
-    "conformance tests{see_below}, and the unit tests now fail again. Files may have changed since you last read "
-    "them."
-)
-# Seeding the first turn: the build folder's file list and the files changed for the FRID.
-MAX_FILE_TREE_ENTRIES = 500
-MAX_RELEVANT_FILES_CHARS = 60_000
+MAX_ISSUE_LENGTH = 10000
 
 
 class FixUnitTests(BaseAction):
-    """Fix failing unit tests with a server-side agent session that spans the fix attempts.
-
-    The first failure starts a session; the agent then drives read/grep/edit/run tool calls
-    (executed here) until it calls submit_fix. The state machine re-runs the unit tests and,
-    if they still fail, the next execution of this action answers that submit_fix call with
-    the new failure output inside the same session, so earlier attempts stay in context.
-
-    During the conformance phase the session also spans unit-test loops: after the conformance
-    tests fixer changes implementation code, the unit tests fail again and the same session is
-    continued, told what the conformance tests fixer changed (which it must preserve).
-    """
-
     SUCCESSFUL_OUTCOME = "unit_tests_fix_generated"
 
     def execute(self, render_context: RenderContext, previous_action_payload: Any | None):
-        if not previous_action_payload or not previous_action_payload.get("previous_unittests_issue"):
+        if not previous_action_payload.get("previous_unittests_issue"):
             raise InternalClientError(
                 "Internal client error: Previous action payload does not contain previous unit tests issue."
             )
-        unittests_issue = previous_action_payload["previous_unittests_issue"]
-        context = render_context.unit_tests_running_context
-        session = render_context.unit_tests_agent_session
-        api = render_context.codeplain_api
-        frid, module_name = render_context.frid_context.frid, render_context.module_name
-        changed_files_before = set(context.changed_files)
-        log_path = render_context.script_execution_history.latest_unit_test_output_path
-        if log_path:
-            agent_tools.register_log_path(log_path, render_context)
-        conformance_tests_fixes = self._get_conformance_tests_fixes(render_context)
-        new_conformance_tests_fixes = conformance_tests_fixes[session.conformance_fixes_handed_off :]
-        if new_conformance_tests_fixes:
-            console.info(
-                f"Unit tests are fixed while preserving {len(new_conformance_tests_fixes)} implementation code "
-                "change(s) made to fix the conformance tests."
-            )
+        previous_unittests_issue = previous_action_payload["previous_unittests_issue"]
 
-        response = None
-        if session.session_id is not None:
-            if context.agent_used_in_this_loop:
-                console.info(f"Continuing agent session {session.session_id} with the new unit tests failure.")
-                output = "The fix was applied, but the unit tests still fail."
-            else:
-                # The session's last fix was accepted in an earlier unit-test loop of this conformance
-                # phase; since then the conformance tests fixer changed the code and the tests fail again.
-                console.info(
-                    f"Continuing agent session {session.session_id}: the unit tests fail again after the "
-                    "implementation was changed to fix the conformance tests."
-                )
-                output = ACCEPTED_THEN_CHANGED_MESSAGE.format(
-                    see_below=" (see the Conformance Tests Fix below)" if new_conformance_tests_fixes else ""
-                )
-                # Files changed outside the session, so earlier read results are stale.
-                context.tool_result_cache.clear()
-            submit_result: dict = {
-                "call_id": session.pending_submit_call_id,
-                "output": output + agent_tools.full_log_pointer(log_path),
-                "test_output": unittests_issue,
-            }
-            if new_conformance_tests_fixes:
-                submit_result["conformance_tests_fixes"] = new_conformance_tests_fixes
-            tool_results = session.pending_tool_results + [submit_result]
-            session.pending_tool_results, session.pending_submit_call_id = [], None
-            response = self._continue_session(render_context, session.session_id, tool_results)
-        if response is None:
-            console.info("Starting an agent session to fix the unit tests.")
-            # Cached read results point at earlier turns, which a new session does not have.
-            context.tool_result_cache.clear()
-            response = api.agent_start(
-                TASK_TYPE,
-                self._build_task_params(render_context, unittests_issue, conformance_tests_fixes),
-                frid,
-                module_name,
-                render_context.run_state,
+        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."
             )
-            session.session_id = response["session_id"]
-        assert session.session_id is not None
-        session.conformance_fixes_handed_off = len(conformance_tests_fixes)
-        context.agent_used_in_this_loop = True
 
-        submitted = False
-        turns = 0
-        while response.get("status") == "tool_calls" and turns < MAX_AGENT_TURNS_PER_ATTEMPT:
-            turns += 1
-            calls = response["calls"]
-            submit_call = next((call for call in calls if call["name"] == SUBMIT_FIX_TOOL), None)
-            tool_results = agent_tools.execute_calls(
-                [call for call in calls if call is not submit_call], render_context
+        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."
             )
-            if submit_call is not None:
-                session.pending_submit_call_id = submit_call["id"]
-                session.pending_tool_results = tool_results
-                submitted = True
-                console.info(f"Agent submitted a fix: {submit_call['args'].get('changes_made', '')}")
-                break
-            response = api.agent_continue(session.session_id, tool_results, frid, module_name, render_context.run_state)
 
-        if not submitted:
-            # The session ended without a submission (finished in text, failed, or used up this
-            # attempt's turn budget) — a fresh session is started if the tests still fail.
-            status = response.get("status")
-            if status == "failed":
-                console.warning(f"Agent session failed: {response.get('error', 'unknown error')}")
-            elif status == "tool_calls":
-                console.warning(f"Agent used {MAX_AGENT_TURNS_PER_ATTEMPT} turns without submitting a fix.")
-            session.reset()
+        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,
+        )
 
-        console.print_files(
-            "Files changed while fixing unit tests:",
-            render_context.build_folder,
-            {path: "" for path in sorted(context.changed_files - changed_files_before)},
-            style=console.OUTPUT_STYLE,
+        _, changed_files = file_utils.update_build_folder_with_rendered_files(
+            render_context.build_folder, existing_files, response_files
         )
-        return self.SUCCESSFUL_OUTCOME, None
 
-    @staticmethod
-    def _get_conformance_tests_fixes(render_context: RenderContext) -> list[dict]:
-        """Implementation code changes the conformance tests fixer made during this conformance phase, oldest
-        first. Empty outside the conformance phase (the implementation and refactoring unit-test loops)."""
-        conformance_tests_running_context = getattr(render_context, "conformance_tests_running_context", None)
-        if conformance_tests_running_context is None:
-            return []
-        return list(getattr(conformance_tests_running_context, "implementation_code_fixes", None) or [])
+        render_context.unit_tests_running_context.changed_files.update(changed_files)
 
-    @staticmethod
-    def _continue_session(render_context: RenderContext, session_id: str, tool_results: list[dict]) -> dict | None:
-        """Continue the session; None if the server no longer has it (expired), so a new one is started."""
-        try:
-            return render_context.codeplain_api.agent_continue(
-                session_id,
-                tool_results,
-                render_context.frid_context.frid,
-                render_context.module_name,
-                render_context.run_state,
-            )
-        except requests.exceptions.HTTPError as e:
-            if e.response is None or e.response.status_code != HTTPStatus.NOT_FOUND:
-                raise
-            console.warning(f"Agent session {session_id} has expired; starting a new one.")
-            render_context.unit_tests_agent_session.reset()
-            return None
+        console.print_files("Files fixed:", render_context.build_folder, response_files, style=console.OUTPUT_STYLE)
 
-    @staticmethod
-    def _build_task_params(
-        render_context: RenderContext, unittests_issue: str, conformance_tests_fixes: list[dict]
-    ) -> dict:
-        frid = render_context.frid_context.frid
-        specifications, _ = plain_spec.get_specifications_for_frid(render_context.plain_source_tree, frid)
-        context = render_context.unit_tests_running_context
-        # The files the conformance tests fixes changed are always seeded, so the agent sees what to preserve.
-        conformance_fix_files = {name for fix in conformance_tests_fixes for name in (fix or {}).get("code_diff") or {}}
-        task_params = {
-            "definitions": "\n".join(specifications.get(plain_spec.DEFINITIONS, [])),
-            "non_functional_requirements": "\n".join(specifications.get(plain_spec.NON_FUNCTIONAL_REQUIREMENTS, [])),
-            "functional_requirements": FixUnitTests._functional_requirements_section(render_context, specifications),
-            "linked_resources": render_context.frid_context.linked_resources,
-            "build_folder": render_context.build_folder,
-            "module_name": render_context.module_name,
-            "unittests_script_content": FixUnitTests._read_script(render_context.unittests_script),
-            "unittests_issue": unittests_issue,
-            "unittests_log_path": render_context.script_execution_history.latest_unit_test_output_path,
-            "file_tree": FixUnitTests._file_tree(render_context.build_folder),
-            "relevant_files": FixUnitTests._relevant_files(
-                render_context.build_folder,
-                render_context.frid_context.changed_files | context.changed_files | conformance_fix_files,
-            ),
-        }
-        if conformance_tests_fixes:
-            task_params["conformance_tests_fixes"] = conformance_tests_fixes
-        session = render_context.unit_tests_agent_session
-        if session.previous_session_id:
-            task_params["previous_session_id"] = session.previous_session_id
-        return task_params
+        return self.SUCCESSFUL_OUTCOME, None
 
     @staticmethod
-    def _file_tree(build_folder: str) -> str:
-        paths = []
-        for root, dirs, files in os.walk(build_folder):
-            dirs[:] = sorted(d for d in dirs if d not in agent_tools.GREP_EXCLUDED_DIRS and not d.startswith("."))
-            paths.extend(os.path.relpath(os.path.join(root, name), build_folder) for name in sorted(files))
-            if len(paths) > MAX_FILE_TREE_ENTRIES:
-                return "\n".join(paths[:MAX_FILE_TREE_ENTRIES]) + "\n... [more files not listed]"
-        return "\n".join(paths)
+    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.
 
-    @staticmethod
-    def _relevant_files(build_folder: str, file_names: set[str]) -> dict[str, str]:
-        """Contents of the given build-relative files, smallest first, within MAX_RELEVANT_FILES_CHARS."""
-        contents = {}
-        for name in file_names:
-            full_path = os.path.join(build_folder, name)
-            if os.path.isfile(full_path):
-                with open(full_path, "r", encoding="utf-8", errors="replace") as f:
-                    contents[name] = f.read()
-        relevant, total = {}, 0
-        for name in sorted(contents, key=lambda n: (len(contents[n]), n)):
-            if total + len(contents[name]) > MAX_RELEVANT_FILES_CHARS:
-                break
-            relevant[name] = contents[name]
-            total += len(contents[name])
-        return dict(sorted(relevant.items()))
+        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
 
-    @staticmethod
-    def _functional_requirements_section(render_context: RenderContext, specifications: dict) -> str:
-        sections = []
-        for module_name, functionalities in render_context.get_required_modules_functionalities().items():
-            sections.append(
-                f"### Module: {module_name} (Already Implemented, for context)\n" + "\n".join(functionalities)
-            )
-        current = specifications.get(plain_spec.FUNCTIONAL_REQUIREMENTS, [])
-        if len(current) > 1:
-            sections.append(
-                f"### Module: {render_context.module_name} (Already Implemented, for context)\n"
-                + "\n".join(current[:-1])
-            )
-        if current:
-            sections.append(f"### Module: {render_context.module_name} (Currently Being Implemented)\n{current[-1]}")
-        return "\n\n".join(sections)
+        implementation_code_fixes = getattr(conformance_tests_running_context, "implementation_code_fixes", None)
+        if not implementation_code_fixes:
+            return None
 
-    @staticmethod
-    def _read_script(script: str | None) -> str:
-        if not script:
-            return ""
-        try:
-            with open(file_utils.add_current_path_if_no_path(script), "r", encoding="utf-8") as f:
-                return f.read()
-        except OSError:
-            return ""
+        return list(implementation_code_fixes)

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(

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()

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]