Resolve context window per access; reset calibrator on model switch; bump to 1.5.4.2

Author: beacoder

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-agent-harness"
-version = "1.5.4.1"
+version = "1.5.4.2"
 description = "A lightweight, hackable mini-OpenCode written in Python."
 readme = "README.md"
 requires-python = ">=3.11"

python_agent_harness/__init__.py

@@ -5,7 +5,7 @@
 from .models import AgentMode, Message, ToolCall, ToolSpec
 from .session import Session
 
-__version__ = "1.5.4.1"
+__version__ = "1.5.4.2"
 
 __all__ = [
     "Session",

python_agent_harness/client.py

@@ -200,7 +200,7 @@ def __init__(
     ) -> None:
         self.base_url = (base_url or config.DEFAULT_BASE_URL).rstrip("/")
         self.api_key = api_key or _default_api_key()
-        self.model = model or config.DEFAULT_MODEL
+        self.model: str = model or config.DEFAULT_MODEL
         self.timeout = timeout
         self.verify = verify if verify is not None else _resolve_ca_bundle()
         self.retry_max = config.API_RETRY_MAX if retry_max is None else retry_max
@@ -212,8 +212,6 @@ def __init__(
         )
         self._config_path = config_path
         self._http = httpx.Client(timeout=timeout, verify=self.verify)
-        # Resolve context window for this model (API discovery + fallbacks)
-        self._context_window = None  # lazy-loaded
         # True while the in-flight request was aborted (Ctrl-C): a
         # connection error on an aborted request must NOT be retried —
         # the user asked to stop.  Cleared at the start of each chat()
@@ -233,19 +231,19 @@ def context_window(self) -> int:
 
         Resolution order: config-file ``context_windows`` overrides
         (via ``config.get_context_window_for_model``) -> CONTEXT_WINDOWS
-        pattern match -> DEFAULT_CONTEXT_WINDOW.  The resolved value is
-        cached for the life of the client.
+        pattern match -> DEFAULT_CONTEXT_WINDOW.  Resolved on every
+        access (no caching), so a runtime model switch or config-file
+        edit takes effect immediately; a malformed config falls back to
+        the default for that access and recovers once the file is fixed.
         """
-        if self._context_window is None:
-            try:
-                self._context_window = config.get_context_window_for_model(
-                    self.model, config_path=self._config_path
-                )
-            except Exception:
-                # a malformed context_windows section must not break
-                # the loop: cache the safe default
-                self._context_window = config.DEFAULT_CONTEXT_WINDOW
-        return self._context_window
+        try:
+            return config.get_context_window_for_model(
+                self.model, config_path=self._config_path
+            )
+        except Exception:
+            # a malformed context_windows section must not break the
+            # loop: use the safe default, retry on the next access
+            return config.DEFAULT_CONTEXT_WINDOW
 
     def close(self) -> None:
         self._http.close()

python_agent_harness/context_manager.py

@@ -21,9 +21,9 @@ class ContextManager:
     from the loop's delegate so the call site keeps resolving them
     through the ``agent`` module namespace (tests patch
     ``python_agent_harness.agent.estimate_payload_tokens``).  The
-    context window comes from the session's client (cached, config-
-    file aware); ``context_window_for`` is only the fallback for
-    clients without the property.
+    context window comes from the session's client (config-file aware,
+    resolved per access); ``context_window_for`` is only the fallback
+    for clients without the property.
     """
 
     def __init__(self, loop: Any) -> None:
@@ -42,9 +42,9 @@ def update_context_ratio(
         )
         loop.session.calibrator.last_raw_estimate = raw
         calibrated = loop.session.calibrator.calibrate(raw)
-        # Prefer the client's cached window (config overrides ->
-        # patterns -> default); fall back to the static resolver for
-        # clients without the property (test doubles).
+        # Prefer the client's window (config overrides -> patterns ->
+        # default, resolved per access); fall back to the static
+        # resolver for clients without the property (test doubles).
         client = loop.session.client
         window = getattr(client, "context_window", None)
         if window is None:

python_agent_harness/session.py

@@ -687,6 +687,9 @@ def switch_model(self, name: str) -> tuple[bool, str]:
         self.client.model = merged["model"]
         self.model = merged["model"]
         self.store.model = merged["model"]
+        # the calibration factor is tokenizer-specific: a factor tuned
+        # to the previous model must not skew estimates for the new one
+        self.calibrator.reset()
         self.backend = merged["backend"]
         self.store.backend = merged["backend"]
         self.temperature = merged["temperature"]

python_agent_harness/token_estimator.py

@@ -68,6 +68,12 @@ def __init__(self) -> None:
         self.factor = 1.0
         self.last_raw_estimate: int | None = None
 
+    def reset(self) -> None:
+        """Drop the calibration factor (model switch: the old factor
+        was tuned to the previous model's tokenizer)."""
+        self.factor = 1.0
+        self.last_raw_estimate = None
+
     def update(self, actual_input: int | None) -> None:
         raw = self.last_raw_estimate
         if actual_input is None or actual_input <= 0 or raw is None or raw <= 0:

tests/test_client.py

@@ -1694,25 +1694,38 @@ def fake_sync(payload, on_delta, on_tool_call, usage):
 
 class TestContextWindow(unittest.TestCase):
     """Client.context_window: config-file overrides -> CONTEXT_WINDOWS
-    patterns -> DEFAULT_CONTEXT_WINDOW.  The resolved value is cached
-    for the life of the client."""
+    patterns -> DEFAULT_CONTEXT_WINDOW.  Resolved on every access (no
+    caching), so model switches and config edits take effect at once."""
 
     def _client(self, model: str, config_path: str | None = None) -> Client:
         c = Client(base_url="http://x/v1", api_key="k", model=model, config_path=config_path)
         self.addCleanup(c.close)
         return c
 
+    def test_model_change_re_resolves_window(self):
+        """Changing client.model (runtime /model switch) resolves the
+        new model's window on the next access."""
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text('{"context_windows": {"fake*": 999999}}', encoding="utf-8")
+            c = self._client(model="fake", config_path=str(p))
+            self.assertEqual(c.context_window, 999_999)
+            c.model = "gpt-5-mini"
+            self.assertEqual(c.context_window, 128_000)
+            c.model = "deepseek-v4-flash"
+            self.assertEqual(c.context_window, 1_000_000)
+
     def test_config_file_override_wins(self):
         """A context_windows entry in the config file beats the
-        built-in table, and the resolved value is cached."""
+        built-in table, and edits are picked up on the next access."""
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / "config.json"
             p.write_text('{"context_windows": {"fake*": 999999}}', encoding="utf-8")
             c = self._client(model="fake", config_path=str(p))
             self.assertEqual(c.context_window, 999_999)
-            # cached: a later config change must not affect the window
+            # no caching: a later config change takes effect immediately
             p.write_text('{"context_windows": {"fake*": 111111}}', encoding="utf-8")
-            self.assertEqual(c.context_window, 999_999)
+            self.assertEqual(c.context_window, 111_111)
 
     def test_config_file_wildcard_matching(self):
         """Config-file patterns support fnmatch wildcards, first match
@@ -1763,11 +1776,16 @@ def test_missing_config_file_uses_table(self):
 
     def test_malformed_config_file_falls_back_to_default(self):
         """A broken context_windows section must not break the loop:
-        the client caches DEFAULT_CONTEXT_WINDOW."""
+        the client uses DEFAULT_CONTEXT_WINDOW for that access, and
+        recovers once the file is fixed (failures are not cached)."""
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / "config.json"
             p.write_text('{"context_windows": {"fake": "not-a-number"}}', encoding="utf-8")
-            self.assertEqual(self._client("fake", str(p)).context_window, 128_000)
+            c = self._client("fake", str(p))
+            self.assertEqual(c.context_window, 128_000)
+            # no caching of the failure: a fixed file is picked up
+            p.write_text('{"context_windows": {"fake*": 999999}}', encoding="utf-8")
+            self.assertEqual(c.context_window, 999_999)
 
 
 if __name__ == "__main__":

tests/test_session.py

@@ -808,6 +808,43 @@ def test_switch_model_unknown_name_fails(self):
         self.assertIn("deepseek", msg)
         self.assertIn("glm", msg)
 
+    def test_switch_model_re_resolves_context_window(self):
+        """Switching models must make the next context-window access
+        resolve for the NEW model: the ratio computation divides by
+        the new model's window, not the old one."""
+        from python_agent_harness.client import Client
+
+        with tempfile.TemporaryDirectory() as d:
+            p = os.path.join(d, "config.json")
+            with open(p, "w", encoding="utf-8") as f:
+                f.write('{"context_windows": {"deepseek-v4*": 1000000}}')
+            client = Client(
+                base_url="http://x/v1", api_key="k", model="gpt-5-mini", config_path=p
+            )
+            self.addCleanup(client.close)
+            session = RecordingSession(
+                model_profiles={"deepseek": {"model": "deepseek-v4-flash"}}
+            )
+            session.client = client
+            self.assertEqual(client.context_window, 128_000)
+            success, _ = session.switch_model("deepseek")
+            self.assertTrue(success)
+            self.assertEqual(client.context_window, 1_000_000)
+
+    def test_switch_model_resets_calibrator(self):
+        """Switching models must drop the token-calibration factor: it
+        was tuned to the previous model's tokenizer and would skew the
+        first context estimates for the new model."""
+        session = RecordingSession(
+            model_profiles={"deepseek": {"model": "deepseek-v4-flash"}}
+        )
+        session.calibrator.factor = 2.5
+        session.calibrator.last_raw_estimate = 1234
+        success, _ = session.switch_model("deepseek")
+        self.assertTrue(success)
+        self.assertEqual(session.calibrator.factor, 1.0)
+        self.assertIsNone(session.calibrator.last_raw_estimate)
+
     def test_switch_model_preserves_conversation_history(self):
         """Switching models does not clear conversation history."""
         from python_agent_harness.models import Message

tests/test_token_estimator.py

@@ -77,6 +77,19 @@ def test_calibrator(self):
         c2.update(500)
         self.assertEqual(c2.factor, 1.0)
 
+    def test_calibrator_reset(self):
+        """reset() drops the factor and raw estimate: after a model
+        switch the next estimate is uncalibrated (identity), and the
+        stale factor tuned to the old tokenizer is gone."""
+        c = TokenCalibrator()
+        c.last_raw_estimate = 1000
+        c.update(3000)
+        self.assertEqual(c.factor, 3.0)
+        c.reset()
+        self.assertEqual(c.factor, 1.0)
+        self.assertIsNone(c.last_raw_estimate)
+        self.assertEqual(c.calibrate(1000), 1000)
+
     def test_payload_tokens(self):
         msgs = [
             {"role": "user", "content": "hello"},