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

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

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.4
+Version: 1.5.4.2
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author: huming
+License-Expression: MIT
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -24,7 +25,7 @@ Dynamic: license-file
 
 # python-agent-harness
 
-**A lightweight, hackable mini-OpenCode written in Python.**
+**A lightweight, hackable mini-OpenCode written in Python.**  
 FSM-driven execution · OpenAI-compatible · built for daily use and easy customization
 
 [![CI](https://github.com/beacoder/python-agent-harness/actions/workflows/ci.yml/badge.svg)](https://github.com/beacoder/python-agent-harness/actions/workflows/ci.yml)
@@ -144,6 +145,10 @@ All LLM settings live in a single JSON configuration file. Environment variables
       "model": "qwen3.5-coder"
     }
   },
+  "context_windows": {
+    "_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,
     "base_url": null,
@@ -183,6 +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 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 → python_agent_harness-1.5.4.2}/README.md

@@ -2,7 +2,7 @@
 
 # python-agent-harness
 
-**A lightweight, hackable mini-OpenCode written in Python.**
+**A lightweight, hackable mini-OpenCode written in Python.**  
 FSM-driven execution · OpenAI-compatible · built for daily use and easy customization
 
 [![CI](https://github.com/beacoder/python-agent-harness/actions/workflows/ci.yml/badge.svg)](https://github.com/beacoder/python-agent-harness/actions/workflows/ci.yml)
@@ -122,6 +122,10 @@ All LLM settings live in a single JSON configuration file. Environment variables
       "model": "qwen3.5-coder"
     }
   },
+  "context_windows": {
+    "_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,
     "base_url": null,
@@ -161,6 +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 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 → python_agent_harness-1.5.4.2}/pyproject.toml

@@ -4,13 +4,15 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-agent-harness"
-version = "1.5.4"
+version = "1.5.4.2"
 description = "A lightweight, hackable mini-OpenCode written in Python."
 readme = "README.md"
 requires-python = ">=3.11"
 authors = [
     { name = "huming" }
 ]
+license = 'MIT'
+license-files = ["LICENSE"]
 dependencies = [
     "rich>=13.0",
     "httpx>=0.27",

{python_agent_harness-1.5.4 → 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"
+__version__ = "1.5.4.2"
 
 __all__ = [
     "Session",

{python_agent_harness-1.5.4 → python_agent_harness-1.5.4.2}/python_agent_harness/cli.py

@@ -221,6 +221,14 @@ def cmd_config(args: argparse.Namespace) -> int:
             print(f"  {name}: model={model_name}, base_url={base_url}")
     else:
         print("models: (none configured — add a 'models' section to use /model)")
+    # Show context-window overrides
+    context_windows = config.load_context_windows_config(args.path)
+    if context_windows:
+        print("context_windows:")
+        for pattern, size in context_windows:
+            print(f"  {pattern}: {size}")
+    else:
+        print("context_windows: (none configured — built-in table in config.py applies)")
     return 0
 
 

{python_agent_harness-1.5.4 → python_agent_harness-1.5.4.2}/python_agent_harness/client.py

@@ -11,6 +11,7 @@ import contextlib
 import json
 import os
 import random
+import socket as _socket
 import threading
 import time
 import uuid
@@ -199,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
@@ -224,6 +225,24 @@ class Client:
             else (_llm_log_path() if config.LLM_LOG_ENABLED else None)
         )
 
+    @property
+    def context_window(self) -> int:
+        """Get the context window for this model.
+
+        Resolution order: config-file ``context_windows`` overrides
+        (via ``config.get_context_window_for_model``) -> CONTEXT_WINDOWS
+        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.
+        """
+        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()
 
@@ -810,8 +829,6 @@ def _abort_inflight_sockets(client: httpx.Client) -> None:
     down an idle socket is harmless (the pool is closed right after
     anyway); any failure is ignored (best effort).
     """
-    import socket as _socket
-
     pool = getattr(getattr(client, "_transport", None), "_pool", None)
     for conn in getattr(pool, "_connections", None) or ():
         try:

{python_agent_harness-1.5.4 → python_agent_harness-1.5.4.2}/python_agent_harness/commands.py

@@ -17,6 +17,7 @@ Tool availability per command:
 from __future__ import annotations
 
 import re
+import subprocess
 from collections.abc import Callable
 from pathlib import Path
 from typing import Any
@@ -35,8 +36,6 @@ def _substitute(text: str, path: str, extra: str | None) -> str:
 
 def _project_root(cwd: str) -> str:
     """Best-effort project root (git dir or parent with AGENTS.md)."""
-    import subprocess
-
     d = Path(cwd).resolve()
     try:
         out = subprocess.run(

{python_agent_harness-1.5.4 → python_agent_harness-1.5.4.2}/python_agent_harness/config.py

@@ -8,10 +8,8 @@ from __future__ import annotations
 import json
 import os
 from pathlib import Path
-from typing import TYPE_CHECKING
 
-if TYPE_CHECKING:
-    from .mcp.config import MCPConfig
+from .mcp.config import MCPConfig
 
 # ---- context management -------------------------------------------------
 CONTEXT_TRIGGER = 0.70
@@ -223,6 +221,10 @@ CONFIG_TEMPLATE = """\
       "model": "gpt-5-mini"
     }}
   }},
+  "context_windows": {{
+    "_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).",
     "profile": null,
@@ -428,8 +430,6 @@ def load_mcp_config(path: str | os.PathLike | None = None) -> MCPConfig:
     ``mcp`` SDK is only needed when servers are actually configured and
     connected — reading the config never requires it.
     """
-    from .mcp.config import MCPConfig
-
     data = _read_config(path)
     section = data.get("mcp") or {}
     if not isinstance(section, dict):
@@ -462,3 +462,80 @@ def load_models_config(path: str | os.PathLike | None = None) -> dict[str, dict]
 
 def mask_secret(value: str | None) -> str:
     return "****" if value else "(unset)"
+
+
+def _match_context_window(model: str) -> int | None:
+    """Match model name against CONTEXT_WINDOWS entries (substring match).
+
+    Args:
+        model: The model ID to match (e.g., "gpt-5-mini", "claude-3-opus")
+
+    Returns:
+        The context window size if matched, None otherwise
+    """
+    lowered = model.lower()
+    for pattern, size in CONTEXT_WINDOWS:
+        if pattern.lower() in lowered:
+            return size
+    return None
+
+
+def load_context_windows_config(
+    path: str | os.PathLike | None = None,
+) -> list[tuple[str, int]]:
+    """Load per-model context-window overrides from the config file.
+
+    Reads the ``context_windows`` object: a mapping of model names or
+    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
+    non-integer size raises ValueError so config errors surface.
+    """
+    try:
+        data = _read_config(path)
+    except ValueError:
+        return []
+    section = data.get("context_windows") or {}
+    if not isinstance(section, dict):
+        raise ValueError(f"config file {_config_path(path)}: context_windows must be an object")
+    entries: list[tuple[str, int]] = []
+    for pattern, size in section.items():
+        if pattern.startswith("_"):
+            continue
+        if isinstance(size, bool) or not isinstance(size, int):
+            raise ValueError(
+                f"config file {_config_path(path)}: context_windows.{pattern} must be an integer"
+            )
+        entries.append((pattern, size))
+    return entries
+
+
+def get_context_window_for_model(
+    model: str,
+    config_path: str | os.PathLike | None = None,
+) -> int:
+    """Get the context window for MODEL: config-file overrides, then
+    the built-in table, then the default.
+
+    The config file's ``context_windows`` object (user overrides) is
+    consulted first (substring match over its keys, first match wins,
+    case-insensitive); then the CONTEXT_WINDOWS table in config.py;
+    then DEFAULT_CONTEXT_WINDOW.
+
+    Args:
+        model: The model ID to look up (e.g. "deepseek-v4-flash")
+        config_path: Optional path to the config file; defaults to the
+            standard config location (config.json).
+
+    Returns:
+        The context window size as an integer.
+    """
+    lowered = model.lower()
+    for pattern, size in load_context_windows_config(config_path):
+        if pattern.lower() in lowered:
+            return size
+    matched = _match_context_window(model)
+    if matched is not None:
+        return matched
+    return DEFAULT_CONTEXT_WINDOW

{python_agent_harness-1.5.4 → python_agent_harness-1.5.4.2}/python_agent_harness/context_manager.py

@@ -20,7 +20,10 @@ class ContextManager:
     ``update_context_ratio`` receives the two token-estimator functions
     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``).
+    ``python_agent_harness.agent.estimate_payload_tokens``).  The
+    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:
@@ -39,7 +42,13 @@ class ContextManager:
         )
         loop.session.calibrator.last_raw_estimate = raw
         calibrated = loop.session.calibrator.calibrate(raw)
-        window = context_window_for(loop.session.model)
+        # 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:
+            window = context_window_for(loop.session.model)
         loop.session.context_ratio = calibrated / float(window)
         loop.session.notify("context")
 

{python_agent_harness-1.5.4 → python_agent_harness-1.5.4.2}/python_agent_harness/mcp/client.py

@@ -18,10 +18,12 @@ content-block dicts), ``structured_content`` and ``is_error``.
 
 from __future__ import annotations
 
+import contextlib
 import os
 from typing import Any
 
 try:
+    import httpx2  # shipped as part of the mcp SDK
     from mcp import Client
     from mcp.client.sse import sse_client
     from mcp.client.stdio import StdioServerParameters, stdio_client
@@ -93,8 +95,6 @@ class MCPClient:
         assert cfg.url is not None
         if cfg.transport == "streamable-http":
             if cfg.headers:
-                import httpx2  # shipped as part of the mcp SDK
-
                 self._http_client = httpx2.AsyncClient(headers=cfg.headers)
                 return streamable_http_client(cfg.url, http_client=self._http_client)
             return streamable_http_client(cfg.url)
@@ -117,8 +117,6 @@ class MCPClient:
 
     async def close(self) -> None:
         """Tear down the connection (best effort, never raises)."""
-        import contextlib
-
         client, self._client = self._client, None
         if client is not None:
             with contextlib.suppress(Exception):  # teardown noise is not an error

{python_agent_harness-1.5.4 → python_agent_harness-1.5.4.2}/python_agent_harness/mcp/manager.py

@@ -200,8 +200,6 @@ class MCPManager:
 
     def disconnect(self, name: str) -> None:
         """Disconnect one server and drop its discovered tools."""
-        import contextlib
-
         client = self._clients.pop(name, None)
         if client is None:
             return

{python_agent_harness-1.5.4 → python_agent_harness-1.5.4.2}/python_agent_harness/persistence.py

@@ -12,6 +12,7 @@ Ported from gptel-agent-harness-session.el.
 
 from __future__ import annotations
 
+import ast
 import os
 import re
 import threading
@@ -284,8 +285,6 @@ class SessionPersistence:
 
 def _parse_metadata_value(value: str) -> str:
     """Parse a repr()-style metadata value, mirroring elisp read-from-string."""
-    import ast
-
     try:
         parsed = ast.literal_eval(value)
         if isinstance(parsed, str):

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

@@ -8,6 +8,7 @@ to reduce drift.
 from __future__ import annotations
 
 import json
+import os
 import re
 
 from . import config
@@ -39,17 +40,20 @@ def estimate_tokens(text: str) -> int:
     return round(latin / 4.0 + cjk / 2.0)
 
 
-def context_window_for(model: str) -> int:
+def context_window_for(model: str, config_path: str | os.PathLike | None = None) -> int:
     """Return the context window for MODEL, or a safe fallback.
 
-    Entries are matched in order using substring matching, so more
-    specific patterns must come before general ones (see config).
+    Delegates to ``config.get_context_window_for_model``: config-file
+    ``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.
+        config_path: Optional config file path; defaults to the
+            standard config location (config.json).
     """
-    lowered = model.lower()
-    for pattern, size in config.CONTEXT_WINDOWS:
-        if pattern in lowered:
-            return size
-    return config.DEFAULT_CONTEXT_WINDOW
+    return config.get_context_window_for_model(model, config_path=config_path)
 
 
 class TokenCalibrator:
@@ -64,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 → python_agent_harness-1.5.4.2/python_agent_harness.egg-info}/PKG-INFO

@@ -1,8 +1,9 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.4
+Version: 1.5.4.2
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author: huming
+License-Expression: MIT
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -24,7 +25,7 @@ Dynamic: license-file
 
 # python-agent-harness
 
-**A lightweight, hackable mini-OpenCode written in Python.**
+**A lightweight, hackable mini-OpenCode written in Python.**  
 FSM-driven execution · OpenAI-compatible · built for daily use and easy customization
 
 [![CI](https://github.com/beacoder/python-agent-harness/actions/workflows/ci.yml/badge.svg)](https://github.com/beacoder/python-agent-harness/actions/workflows/ci.yml)
@@ -144,6 +145,10 @@ All LLM settings live in a single JSON configuration file. Environment variables
       "model": "qwen3.5-coder"
     }
   },
+  "context_windows": {
+    "_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,
     "base_url": null,
@@ -183,6 +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 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 → python_agent_harness-1.5.4.2}/tests/test_client.py

@@ -6,6 +6,7 @@ import sys
 import tempfile
 import time
 import unittest
+from pathlib import Path
 from unittest import mock
 
 import httpx
@@ -27,13 +28,14 @@ def make_client(
     retry_max: int | None = None,
     retry_base_delay: float | None = None,
     retry_max_delay: float | None = None,
+    model: str = "fake",
 ) -> Client:
     srv = serve()
     host, port = srv.server_address
     c = Client(
         base_url=f"http://{host}:{port}/v1",
         api_key="test",
-        model="fake",
+        model=model,
         retry_max=retry_max,
         retry_base_delay=retry_base_delay,
         retry_max_delay=retry_max_delay,
@@ -1690,5 +1692,113 @@ class TestAuthRefreshOn401(unittest.TestCase):
         c.close()
 
 
+class TestContextWindow(unittest.TestCase):
+    """Client.context_window: config-file overrides -> CONTEXT_WINDOWS
+    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 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)
+            # 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_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}}',
+                encoding="utf-8",
+            )
+            # "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)
+
+    def test_unknown_model_in_config_file_falls_to_table(self):
+        """Config-file overrides that don't match fall through to the
+        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")
+            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 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 table match ->
+        DEFAULT_CONTEXT_WINDOW."""
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text('{"llm": {"model": "x"}}', encoding="utf-8")
+            self.assertEqual(
+                self._client("totally-unknown-model", str(p)).context_window,
+                config.DEFAULT_CONTEXT_WINDOW,
+            )
+
+    def test_missing_config_file_uses_table(self):
+        """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 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")
+            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__":
     unittest.main()

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

@@ -180,6 +180,149 @@ class TestConfigFile(unittest.TestCase):
         self.assertIn("reasoning_effort", config.CONFIG_TEMPLATE)
         self.assertIn('"stream"', config.CONFIG_TEMPLATE)
         self.assertIn('"subagent_llm"', config.CONFIG_TEMPLATE)
+        self.assertIn('"context_windows"', config.CONFIG_TEMPLATE)
+
+
+class TestContextWindowsConfig(unittest.TestCase):
+    """Config-file context-window overrides: loaded from the
+    ``context_windows`` object, matched before the built-in table."""
+
+    def setUp(self):
+        self._saved = {k: os.environ.get(k) for k in ENV_KEYS}
+        for k in ENV_KEYS:
+            os.environ.pop(k, None)
+
+    def tearDown(self):
+        for k, v in self._saved.items():
+            if v is None:
+                os.environ.pop(k, None)
+            else:
+                os.environ[k] = v
+
+    def test_missing_file_returns_empty(self):
+        self.assertEqual(config.load_context_windows_config("/no/such/file.json"), [])
+
+    def test_empty_section_returns_empty(self):
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text('{"llm": {"model": "m"}}', encoding="utf-8")
+            self.assertEqual(config.load_context_windows_config(p), [])
+
+    def test_bad_json_returns_empty(self):
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text("not {valid json", encoding="utf-8")
+            self.assertEqual(config.load_context_windows_config(p), [])
+
+    def test_overrides_loaded_in_order(self):
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text(
+                '{"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)],
+            )
+
+    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}}',
+                encoding="utf-8",
+            )
+            self.assertEqual(config.load_context_windows_config(p), [("kimi", 256000)])
+
+    def test_section_must_be_object(self):
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text('{"context_windows": "nope"}', encoding="utf-8")
+            with self.assertRaises(ValueError):
+                config.load_context_windows_config(p)
+
+    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")
+            with self.assertRaises(ValueError):
+                config.load_context_windows_config(p)
+
+    def test_bool_size_rejected(self):
+        """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")
+            with self.assertRaises(ValueError):
+                config.load_context_windows_config(p)
+
+    def test_get_context_window_precedence(self):
+        """Config-file override -> CONTEXT_WINDOWS -> default."""
+        with tempfile.TemporaryDirectory() as d:
+            p = Path(d) / "config.json"
+            p.write_text(
+                '{"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)
+            # config-file match beats the built-in table
+            self.assertEqual(config.get_context_window_for_model("gpt-4-turbo", p), 300000)
+            # built-in table still applies when no override matches
+            self.assertEqual(config.get_context_window_for_model("gpt-5-mini", p), 128000)
+            self.assertEqual(config.get_context_window_for_model("kimi-k2.7-0613", p), 256000)
+            # unknown model -> default
+            self.assertEqual(
+                config.get_context_window_for_model("unknown-model", p),
+                config.DEFAULT_CONTEXT_WINDOW,
+            )
+
+    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")
+            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"),
+            1_000_000,
+        )
+        self.assertEqual(
+            config.get_context_window_for_model("totally-unknown", "/no/such/file.json"),
+            config.DEFAULT_CONTEXT_WINDOW,
+        )
 
 
 class TestSubagentLlmConfig(unittest.TestCase):

{python_agent_harness-1.5.4 → 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 → python_agent_harness-1.5.4.2}/tests/test_token_estimator.py

@@ -1,4 +1,7 @@
+import os
+import tempfile
 import unittest
+from pathlib import Path
 
 from python_agent_harness.token_estimator import (
     TokenCalibrator,
@@ -11,6 +14,18 @@ from python_agent_harness.token_estimator import (
 
 
 class TestTokenizer(unittest.TestCase):
+    def setUp(self):
+        # pin the default config path to a nonexistent file so the
+        # tests never read the user's real config.json
+        self._saved_cfg = os.environ.get("PYTHON_AGENT_HARNESS_CONFIG")
+        os.environ["PYTHON_AGENT_HARNESS_CONFIG"] = "/no/such/harness-config.json"
+
+    def tearDown(self):
+        if self._saved_cfg is None:
+            os.environ.pop("PYTHON_AGENT_HARNESS_CONFIG", None)
+        else:
+            os.environ["PYTHON_AGENT_HARNESS_CONFIG"] = self._saved_cfg
+
     def test_empty_text_zero_tokens(self):
         self.assertEqual(estimate_tokens(""), 0)
 
@@ -26,10 +41,26 @@ class TestTokenizer(unittest.TestCase):
 
     def test_context_window_matching(self):
         self.assertEqual(context_window_for("deepseek-v4"), 1_000_000)
+        self.assertEqual(context_window_for("deepseek-v4-flash"), 1_000_000)
+        self.assertEqual(context_window_for("deepseek-v4-pro"), 1_000_000)
         self.assertEqual(context_window_for("gpt-5-mini"), 128_000)
+        self.assertEqual(context_window_for("gpt-5-pro"), 400_000)
         self.assertEqual(context_window_for("claude-sonnet"), 200_000)
+        self.assertEqual(context_window_for("qwen3.5-32b"), 131_072)
+        self.assertEqual(context_window_for("kimi-k2.7-0613"), 256_000)
         self.assertEqual(context_window_for("unknown-model"), 128_000)
 
+    def test_context_window_config_file_override(self):
+        """A context_windows section in the config file overrides the
+        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")
+            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)
+            self.assertEqual(context_window_for("unknown-model", str(p)), 128_000)
+
     def test_calibrator(self):
         c = TokenCalibrator()
         c.last_raw_estimate = 1000
@@ -46,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"},