"""A released kernel does not change the provider request, so the prompt cache survives.

Every request carries the tools and system prompt. When any of it is computed
from the live kernel, a release followed by a restore changes the bytes and the
provider reads no cache on every resumed turn. Only real requests recorded by
the fake provider across a real release show it.
"""

import json
import unittest

from harness import Albedo, Provider, exclusive, latest_user, python, text, wait_until


@exclusive
class ReleaseRequestTests(unittest.TestCase):
    def test_the_request_after_a_release_extends_the_one_before_it(self):
        def script(request):
            if request["input"][-1].get("role") == "user":
                if latest_user(request).split("<system-note>")[0] == "define":
                    return python("answer = 42")
            return text("ok")

        provider = Provider(script)
        self.addCleanup(provider.close)

        def prepare(app):
            app.env.update(
                ALBEDO_IDLE_SECONDS="1",
                ALBEDO_KERNEL_SPARES="2",
                ALBEDO_KERNEL_RELEASE_WITH_SPARE="1",
            )

        with Albedo(provider, protocol="responses", prepare=prepare) as app:
            session = app.session()
            app.prompt(session, "define").close()
            app.idle(session)
            before = len(provider.requests)
            state = app.home / "kernels" / f"{session}.state"
            wait_until(state.exists, 20, "the resting kernel was not released")
            app.prompt(session, "again").close()
            app.idle(session)
            requests = [item["request"] for item in provider.requests]
            self.assertEqual(
                latest_user(provider.requests[before]["request"]),
                "again",
                "a lossless restore added a note to the turn",
            )
            last_before, first_after = requests[before - 1], requests[before]
            self.assertEqual(first_after["tools"], last_before["tools"])
            self.assertEqual(
                first_after.get("instructions"), last_before.get("instructions")
            )
            prefix = last_before["input"]
            self.assertEqual(
                json.dumps(first_after["input"][: len(prefix)], sort_keys=True),
                json.dumps(prefix, sort_keys=True),
                "history before the release changed",
            )