python-agent-harness 1.5.4.1__tar.gz → 1.5.4.2__tar.gz

{python_agent_harness-1.5.4.1/python_agent_harness.egg-info → python_agent_harness-1.5.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.4.1
+Version: 1.5.4.2
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author: huming
 License-Expression: MIT
@@ -146,8 +146,8 @@ All LLM settings live in a single JSON configuration file. Environment variables
     }
   },
   "context_windows": {
-    "_comment": "Optional per-model context-window overrides (tokens). Keys are model names or fnmatch patterns (e.g. deepseek-v4* = 1000000); matched in file order, first match wins. Overrides the built-in CONTEXT_WINDOWS table in config.py.",
-    "deepseek-v4*": 1000000
+    "_comment": "Optional per-model context-window overrides (tokens). Keys are model names or substrings (e.g. deepseek-v4 = 1000000); matched in file order, first match wins. Overrides the built-in CONTEXT_WINDOWS table in config.py.",
+    "deepseek-v4": 1000000
   },
   "subagent_llm": {
     "profile": null,
@@ -188,7 +188,7 @@ All LLM settings live in a single JSON configuration file. Environment variables
 
 - **`llm`** — main LLM configuration. Optional keys include `backend`, `temperature`, `max_tokens`, `timeout`, `reasoning_effort`, and `stream`. Values such as `reasoning_effort` are passed to the API as-is when set. `run --no-stream` overrides `stream`.
 - **`models`** — named LLM profiles for runtime switching with `/model`. A profile is a partial settings dictionary; unset keys inherit from the main `llm`. `default` restores the main LLM configuration.
-- **`context_windows`** — optional per-model context-window overrides (tokens). Keys are model names or fnmatch patterns (e.g., `deepseek-v4*`); matched in file order, first match wins. Overrides the built-in `CONTEXT_WINDOWS` table in `config.py`.
+- **`context_windows`** — optional per-model context-window overrides (tokens). Keys are model names or substrings (e.g., `deepseek-v4`); matched in file order, first match wins. Overrides the built-in `CONTEXT_WINDOWS` table in `config.py`.
 - **`subagent_llm`** — LLM configuration for `Agent` tool requests. Unset values inherit from the main `llm`. Set `profile` to reuse a profile from `models`. Precedence is: profile settings > explicit `subagent_llm` settings > main `llm` > environment variables.
 - **`paths.context_path` / `paths.skill_path`** — locations from which to load context files and skills. When unset, the project-local `<project>/contexts` and `<project>/skills` directories are used.
 - **`mcp.servers`** — MCP server configuration. Requires the `[mcp]` extra. Each server supports `transport`, `command`, `args`, `env`, `url`, `headers`, `parallel`, `timeout`, and `enabled`.

{python_agent_harness-1.5.4.1 → python_agent_harness-1.5.4.2}/README.md

@@ -123,8 +123,8 @@ All LLM settings live in a single JSON configuration file. Environment variables
     }
   },
   "context_windows": {
-    "_comment": "Optional per-model context-window overrides (tokens). Keys are model names or fnmatch patterns (e.g. deepseek-v4* = 1000000); matched in file order, first match wins. Overrides the built-in CONTEXT_WINDOWS table in config.py.",
-    "deepseek-v4*": 1000000
+    "_comment": "Optional per-model context-window overrides (tokens). Keys are model names or substrings (e.g. deepseek-v4 = 1000000); matched in file order, first match wins. Overrides the built-in CONTEXT_WINDOWS table in config.py.",
+    "deepseek-v4": 1000000
   },
   "subagent_llm": {
     "profile": null,
@@ -165,7 +165,7 @@ All LLM settings live in a single JSON configuration file. Environment variables
 
 - **`llm`** — main LLM configuration. Optional keys include `backend`, `temperature`, `max_tokens`, `timeout`, `reasoning_effort`, and `stream`. Values such as `reasoning_effort` are passed to the API as-is when set. `run --no-stream` overrides `stream`.
 - **`models`** — named LLM profiles for runtime switching with `/model`. A profile is a partial settings dictionary; unset keys inherit from the main `llm`. `default` restores the main LLM configuration.
-- **`context_windows`** — optional per-model context-window overrides (tokens). Keys are model names or fnmatch patterns (e.g., `deepseek-v4*`); matched in file order, first match wins. Overrides the built-in `CONTEXT_WINDOWS` table in `config.py`.
+- **`context_windows`** — optional per-model context-window overrides (tokens). Keys are model names or substrings (e.g., `deepseek-v4`); matched in file order, first match wins. Overrides the built-in `CONTEXT_WINDOWS` table in `config.py`.
 - **`subagent_llm`** — LLM configuration for `Agent` tool requests. Unset values inherit from the main `llm`. Set `profile` to reuse a profile from `models`. Precedence is: profile settings > explicit `subagent_llm` settings > main `llm` > environment variables.
 - **`paths.context_path` / `paths.skill_path`** — locations from which to load context files and skills. When unset, the project-local `<project>/contexts` and `<project>/skills` directories are used.
 - **`mcp.servers`** — MCP server configuration. Requires the `[mcp]` extra. Each server supports `transport`, `command`, `args`, `env`, `url`, `headers`, `parallel`, `timeout`, and `enabled`.

{python_agent_harness-1.5.4.1 → python_agent_harness-1.5.4.2}/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-1.5.4.1 → python_agent_harness-1.5.4.2}/python_agent_harness/__init__.py

@@ -5,7 +5,7 @@ from .mcp.manager import MCPManager
 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-1.5.4.1 → python_agent_harness-1.5.4.2}/python_agent_harness/client.py

@@ -200,7 +200,7 @@ class Client:
     ) -> 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 @@ class Client:
         )
         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,17 @@ class Client:
 
         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-1.5.4.1 → python_agent_harness-1.5.4.2}/python_agent_harness/config.py

@@ -5,7 +5,6 @@ Mirrors the defcustom defaults of the Emacs gptel-agent-harness.
 
 from __future__ import annotations
 
-import fnmatch
 import json
 import os
 from pathlib import Path
@@ -16,32 +15,22 @@ from .mcp.config import MCPConfig
 CONTEXT_TRIGGER = 0.70
 
 # Entries are matched in order (first match wins): put more specific
-# patterns before general ones. Supports wildcards (*).  Trailing `*`
-# on explicit entries preserves prefix matching for suffixed model
-# names (e.g. "deepseek-v4-flash" -> deepseek-v4*), matching the
-# legacy substring behavior.
+# patterns before general ones.
 CONTEXT_WINDOWS: list[tuple[str, int]] = [
-    ("gpt-5-mini*", 128_000),
-    ("gpt-5*", 400_000),
-    ("gpt-oss-120b*", 128_000),
-    ("claude*", 200_000),
-    ("deepseek-v3*", 128_000),
-    ("deepseek-v4*", 1_000_000),
-    ("qwen3.5*", 131_072),
-    ("qwen3.6*", 262_144),
-    ("qwen3.8*", 262_144),
-    ("qwen3*", 131_072),
-    ("glm-5.2*", 1_000_000),
-    ("glm-5.1*", 128_000),
-    ("kimi-k2.7*", 256_000),
-    ("kimi*", 128_000),
-    # Wildcard fallbacks for unknown models
-    ("gpt-*", 128_000),
-    ("claude-*", 200_000),
-    ("deepseek-*", 128_000),
-    ("qwen-*", 128_000),
-    ("glm-*", 128_000),
-    ("kimi-*", 128_000),
+    ("gpt-5-mini", 128_000),
+    ("gpt-5", 400_000),
+    ("gpt-oss-120b", 128_000),
+    ("claude", 200_000),
+    ("deepseek-v3", 128_000),
+    ("deepseek-v4", 1_000_000),
+    ("qwen3.5", 131_072),
+    ("qwen3.6", 262_144),
+    ("qwen3.8", 262_144),
+    ("qwen3", 131_072),
+    ("glm-5.2", 1_000_000),
+    ("glm-5.1", 128_000),
+    ("kimi-k2.7", 256_000),
+    ("kimi", 128_000),
 ]
 DEFAULT_CONTEXT_WINDOW = 128_000
 
@@ -233,8 +222,8 @@ CONFIG_TEMPLATE = """\
     }}
   }},
   "context_windows": {{
-    "_comment": "Optional per-model context-window overrides (tokens). Keys are model names or fnmatch patterns (e.g. deepseek-v4* = 1000000); matched in file order, first match wins. Overrides the built-in CONTEXT_WINDOWS table in config.py. Remove this section to use the built-in table.",
-    "deepseek-v4*": 1000000
+    "_comment": "Optional per-model context-window overrides (tokens). Keys are model names or substrings (e.g. deepseek-v4 = 1000000); matched in file order, first match wins. Overrides the built-in CONTEXT_WINDOWS table in config.py. Remove this section to use the built-in table.",
+    "deepseek-v4": 1000000
   }},
   "subagent_llm": {{
     "_comment": "Optional overrides for sub-agent (Agent tool) requests, e.g. a cheaper model. Every key is optional; unset keys inherit the main llm settings above. Set 'profile' to a name from the 'models' section to reuse a model profile (profile settings win over explicit keys below).",
@@ -476,7 +465,7 @@ def mask_secret(value: str | None) -> str:
 
 
 def _match_context_window(model: str) -> int | None:
-    """Match model name against CONTEXT_WINDOWS patterns (supports wildcards).
+    """Match model name against CONTEXT_WINDOWS entries (substring match).
 
     Args:
         model: The model ID to match (e.g., "gpt-5-mini", "claude-3-opus")
@@ -486,7 +475,7 @@ def _match_context_window(model: str) -> int | None:
     """
     lowered = model.lower()
     for pattern, size in CONTEXT_WINDOWS:
-        if fnmatch.fnmatch(lowered, pattern.lower()):
+        if pattern.lower() in lowered:
             return size
     return None
 
@@ -497,7 +486,7 @@ def load_context_windows_config(
     """Load per-model context-window overrides from the config file.
 
     Reads the ``context_windows`` object: a mapping of model names or
-    fnmatch patterns (matched in file order, first match wins) to token
+    substrings (matched in file order, first match wins) to token
     counts.  Keys starting with ``_`` are comments and skipped.  A
     missing file, missing section, or unreadable JSON yields ``[]``
     (callers fall back to the built-in table); a malformed section or
@@ -530,7 +519,7 @@ def get_context_window_for_model(
     the built-in table, then the default.
 
     The config file's ``context_windows`` object (user overrides) is
-    consulted first (fnmatch over its patterns, first match wins,
+    consulted first (substring match over its keys, first match wins,
     case-insensitive); then the CONTEXT_WINDOWS table in config.py;
     then DEFAULT_CONTEXT_WINDOW.
 
@@ -544,7 +533,7 @@ def get_context_window_for_model(
     """
     lowered = model.lower()
     for pattern, size in load_context_windows_config(config_path):
-        if fnmatch.fnmatch(lowered, pattern.lower()):
+        if pattern.lower() in lowered:
             return size
     matched = _match_context_window(model)
     if matched is not None:

{python_agent_harness-1.5.4.1 → python_agent_harness-1.5.4.2}/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 @@ class ContextManager:
         )
         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-1.5.4.1 → python_agent_harness-1.5.4.2}/python_agent_harness/session.py

@@ -687,6 +687,9 @@ class Session:
         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-1.5.4.1 → python_agent_harness-1.5.4.2}/python_agent_harness/token_estimator.py

@@ -44,9 +44,9 @@ def context_window_for(model: str, config_path: str | os.PathLike | None = None)
     """Return the context window for MODEL, or a safe fallback.
 
     Delegates to ``config.get_context_window_for_model``: config-file
-    ``context_windows`` overrides (config.json) first, then fnmatch
-    over CONTEXT_WINDOWS (first match wins, case-insensitive), then
-    DEFAULT_CONTEXT_WINDOW.
+    ``context_windows`` overrides (config.json) first, then substring
+    match over CONTEXT_WINDOWS (first match wins, case-insensitive),
+    then DEFAULT_CONTEXT_WINDOW.
 
     Args:
         model: The model ID to look up.
@@ -68,6 +68,12 @@ class TokenCalibrator:
         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:

{python_agent_harness-1.5.4.1 → python_agent_harness-1.5.4.2/python_agent_harness.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.4.1
+Version: 1.5.4.2
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author: huming
 License-Expression: MIT
@@ -146,8 +146,8 @@ All LLM settings live in a single JSON configuration file. Environment variables
     }
   },
   "context_windows": {
-    "_comment": "Optional per-model context-window overrides (tokens). Keys are model names or fnmatch patterns (e.g. deepseek-v4* = 1000000); matched in file order, first match wins. Overrides the built-in CONTEXT_WINDOWS table in config.py.",
-    "deepseek-v4*": 1000000
+    "_comment": "Optional per-model context-window overrides (tokens). Keys are model names or substrings (e.g. deepseek-v4 = 1000000); matched in file order, first match wins. Overrides the built-in CONTEXT_WINDOWS table in config.py.",
+    "deepseek-v4": 1000000
   },
   "subagent_llm": {
     "profile": null,
@@ -188,7 +188,7 @@ All LLM settings live in a single JSON configuration file. Environment variables
 
 - **`llm`** — main LLM configuration. Optional keys include `backend`, `temperature`, `max_tokens`, `timeout`, `reasoning_effort`, and `stream`. Values such as `reasoning_effort` are passed to the API as-is when set. `run --no-stream` overrides `stream`.
 - **`models`** — named LLM profiles for runtime switching with `/model`. A profile is a partial settings dictionary; unset keys inherit from the main `llm`. `default` restores the main LLM configuration.
-- **`context_windows`** — optional per-model context-window overrides (tokens). Keys are model names or fnmatch patterns (e.g., `deepseek-v4*`); matched in file order, first match wins. Overrides the built-in `CONTEXT_WINDOWS` table in `config.py`.
+- **`context_windows`** — optional per-model context-window overrides (tokens). Keys are model names or substrings (e.g., `deepseek-v4`); matched in file order, first match wins. Overrides the built-in `CONTEXT_WINDOWS` table in `config.py`.
 - **`subagent_llm`** — LLM configuration for `Agent` tool requests. Unset values inherit from the main `llm`. Set `profile` to reuse a profile from `models`. Precedence is: profile settings > explicit `subagent_llm` settings > main `llm` > environment variables.
 - **`paths.context_path` / `paths.skill_path`** — locations from which to load context files and skills. When unset, the project-local `<project>/contexts` and `<project>/skills` directories are used.
 - **`mcp.servers`** — MCP server configuration. Requires the `[mcp]` extra. Each server supports `transport`, `command`, `args`, `env`, `url`, `headers`, `parallel`, `timeout`, and `enabled`.

{python_agent_harness-1.5.4.1 → python_agent_harness-1.5.4.2}/tests/test_client.py

@@ -1694,36 +1694,49 @@ class TestAuthRefreshOn401(unittest.TestCase):
 
 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")
+            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
-            p.write_text('{"context_windows": {"fake*": 111111}}', encoding="utf-8")
-            self.assertEqual(c.context_window, 999_999)
+            # no caching: a later config change takes effect immediately
+            p.write_text('{"context_windows": {"fake": 111111}}', encoding="utf-8")
+            self.assertEqual(c.context_window, 111_111)
 
-    def test_config_file_wildcard_matching(self):
-        """Config-file patterns support fnmatch wildcards, first match
+    def test_config_file_substring_matching(self):
+        """Config-file keys are matched as substrings, first match
         wins in file order."""
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / "config.json"
             p.write_text(
-                '{"context_windows": {"gpt-4*": 500000, "gpt-4-turbo": 300000}}',
+                '{"context_windows": {"gpt-4": 500000, "gpt-4-turbo": 300000}}',
                 encoding="utf-8",
             )
-            # "gpt-4-turbo" hits the FIRST entry ("gpt-4*")
+            # "gpt-4-turbo" hits the FIRST entry ("gpt-4")
             self.assertEqual(self._client("gpt-4-turbo", str(p)).context_window, 500_000)
             self.assertEqual(self._client("gpt-4o", str(p)).context_window, 500_000)
 
@@ -1732,19 +1745,19 @@ class TestContextWindow(unittest.TestCase):
         built-in CONTEXT_WINDOWS table."""
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / "config.json"
-            p.write_text('{"context_windows": {"deepseek-v4*": 1000000}}', encoding="utf-8")
+            p.write_text('{"context_windows": {"deepseek-v4": 1000000}}', encoding="utf-8")
             self.assertEqual(self._client("gpt-5-mini", str(p)).context_window, 128_000)
             self.assertEqual(self._client("deepseek-v4-flash", str(p)).context_window, 1_000_000)
 
     def test_fallback_to_pattern_match(self):
-        """No config-file overrides -> CONTEXT_WINDOWS wildcard."""
+        """No config-file overrides -> CONTEXT_WINDOWS substring match."""
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / "config.json"
             p.write_text('{"llm": {"model": "x"}}', encoding="utf-8")
             self.assertEqual(self._client("gpt-4-turbo", str(p)).context_window, 128_000)
 
     def test_fallback_to_default(self):
-        """No config-file overrides and no pattern match ->
+        """No config-file overrides and no table match ->
         DEFAULT_CONTEXT_WINDOW."""
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / "config.json"
@@ -1755,19 +1768,36 @@ class TestContextWindow(unittest.TestCase):
             )
 
     def test_missing_config_file_uses_table(self):
-        """No config file at all -> CONTEXT_WINDOWS patterns."""
+        """No config file at all -> CONTEXT_WINDOWS table."""
         self.assertEqual(
             self._client("deepseek-v4-flash", "/no/such/config.json").context_window,
             1_000_000,
         )
 
+    def test_provider_prefixed_model_name(self):
+        """Provider-prefixed names (e.g. ZhipuAI/GLM-5.2) resolve the
+        right window via case-insensitive substring match."""
+        self.assertEqual(
+            self._client("ZhipuAI/GLM-5.2", "/no/such/config.json").context_window,
+            1_000_000,
+        )
+        self.assertEqual(
+            self._client("ZhipuAI/GLM-5.1", "/no/such/config.json").context_window,
+            128_000,
+        )
+
     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__":

{python_agent_harness-1.5.4.1 → python_agent_harness-1.5.4.2}/tests/test_config.py

@@ -218,22 +218,22 @@ class TestContextWindowsConfig(unittest.TestCase):
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / "config.json"
             p.write_text(
-                '{"context_windows": {"deepseek-v4*": 1000000, "gpt-5*": 400000}}',
+                '{"context_windows": {"deepseek-v4": 1000000, "gpt-5": 400000}}',
                 encoding="utf-8",
             )
             self.assertEqual(
                 config.load_context_windows_config(p),
-                [("deepseek-v4*", 1000000), ("gpt-5*", 400000)],
+                [("deepseek-v4", 1000000), ("gpt-5", 400000)],
             )
 
     def test_comment_keys_skipped(self):
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / "config.json"
             p.write_text(
-                '{"context_windows": {"_comment": "hi", "kimi*": 256000}}',
+                '{"context_windows": {"_comment": "hi", "kimi": 256000}}',
                 encoding="utf-8",
             )
-            self.assertEqual(config.load_context_windows_config(p), [("kimi*", 256000)])
+            self.assertEqual(config.load_context_windows_config(p), [("kimi", 256000)])
 
     def test_section_must_be_object(self):
         with tempfile.TemporaryDirectory() as d:
@@ -245,7 +245,7 @@ class TestContextWindowsConfig(unittest.TestCase):
     def test_size_must_be_integer(self):
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / "config.json"
-            p.write_text('{"context_windows": {"m*": "big"}}', encoding="utf-8")
+            p.write_text('{"context_windows": {"m": "big"}}', encoding="utf-8")
             with self.assertRaises(ValueError):
                 config.load_context_windows_config(p)
 
@@ -253,7 +253,7 @@ class TestContextWindowsConfig(unittest.TestCase):
         """True is an int subclass but not a valid token count."""
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / "config.json"
-            p.write_text('{"context_windows": {"m*": true}}', encoding="utf-8")
+            p.write_text('{"context_windows": {"m": true}}', encoding="utf-8")
             with self.assertRaises(ValueError):
                 config.load_context_windows_config(p)
 
@@ -262,7 +262,7 @@ class TestContextWindowsConfig(unittest.TestCase):
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / "config.json"
             p.write_text(
-                '{"context_windows": {"deepseek-v4*": 1000000, "gpt-4-turbo": 300000}}',
+                '{"context_windows": {"deepseek-v4": 1000000, "gpt-4-turbo": 300000}}',
                 encoding="utf-8",
             )
             self.assertEqual(config.get_context_window_for_model("deepseek-v4-flash", p), 1000000)
@@ -280,9 +280,40 @@ class TestContextWindowsConfig(unittest.TestCase):
     def test_get_context_window_case_insensitive(self):
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / "config.json"
-            p.write_text('{"context_windows": {"DeepSeek-V4*": 1000000}}', encoding="utf-8")
+            p.write_text('{"context_windows": {"DeepSeek-V4": 1000000}}', encoding="utf-8")
             self.assertEqual(config.get_context_window_for_model("deepseek-v4-flash", p), 1000000)
 
+    def test_get_context_window_provider_prefixed_name(self):
+        """Provider-prefixed model names (e.g. "ZhipuAI/GLM-5.2") match
+        their table entry via case-insensitive substring match."""
+        # provider prefix + uppercase org, model name in the middle
+        self.assertEqual(
+            config.get_context_window_for_model("ZhipuAI/GLM-5.2", "/no/such/config.json"),
+            1_000_000,
+        )
+        # lowercased provider prefix matches too
+        self.assertEqual(
+            config.get_context_window_for_model("zhipuai/glm-5.2", "/no/such/config.json"),
+            1_000_000,
+        )
+        # plain model name still matches
+        self.assertEqual(
+            config.get_context_window_for_model("glm-5.2", "/no/such/config.json"),
+            1_000_000,
+        )
+        # a different minor version must NOT hit the glm-5.2 entry
+        self.assertEqual(
+            config.get_context_window_for_model("ZhipuAI/GLM-5.3", "/no/such/config.json"),
+            config.DEFAULT_CONTEXT_WINDOW,
+        )
+        # provider prefix must not break other families either
+        self.assertEqual(
+            config.get_context_window_for_model(
+                "DeepSeek/deepseek-v4-flash", "/no/such/config.json"
+            ),
+            1_000_000,
+        )
+
     def test_get_context_window_no_file(self):
         self.assertEqual(
             config.get_context_window_for_model("deepseek-v4", "/no/such/file.json"),

{python_agent_harness-1.5.4.1 → python_agent_harness-1.5.4.2}/tests/test_session.py

@@ -808,6 +808,37 @@ class TestModelSwitching(unittest.TestCase):
         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

{python_agent_harness-1.5.4.1 → python_agent_harness-1.5.4.2}/tests/test_token_estimator.py

@@ -55,7 +55,7 @@ class TestTokenizer(unittest.TestCase):
         built-in table (matched before CONTEXT_WINDOWS)."""
         with tempfile.TemporaryDirectory() as d:
             p = Path(d) / "config.json"
-            p.write_text('{"context_windows": {"deepseek-v4*": 2000000}}', encoding="utf-8")
+            p.write_text('{"context_windows": {"deepseek-v4": 2000000}}', encoding="utf-8")
             self.assertEqual(context_window_for("deepseek-v4-flash", str(p)), 2_000_000)
             # models the override doesn't cover still use the table
             self.assertEqual(context_window_for("gpt-5-mini", str(p)), 128_000)
@@ -77,6 +77,19 @@ class TestTokenizer(unittest.TestCase):
         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"},