python-agent-harness 1.5.4.6__tar.gz → 1.5.4.8__tar.gz

{python_agent_harness-1.5.4.6/python_agent_harness.egg-info → python_agent_harness-1.5.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-agent-harness
-Version: 1.5.4.6
+Version: 1.5.4.8
 Summary: A lightweight, hackable mini-OpenCode written in Python.
 Author: huming
 License-Expression: MIT
@@ -138,15 +138,17 @@ All LLM settings live in a single JSON configuration file. Environment variables
     "_comment": "Named LLM profiles for /model switching. Partial settings; unset keys inherit the main llm.",
     "deepseek": {
       "base_url": "https://api.deepseek.com/v1",
-      "model": "deepseek-chat",
-      "context_window": 128000
+      "model": "deepseek-chat"
     },
     "qwen": {
       "base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
-      "model": "qwen3.5-coder",
-      "context_window": 131072
+      "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,
@@ -156,8 +158,7 @@ All LLM settings live in a single JSON configuration file. Environment variables
     "max_tokens": null,
     "timeout": null,
     "reasoning_effort": null,
-    "stream": null,
-    "context_window": null
+    "stream": null
   },
   "paths": {
     "context_path": null,
@@ -185,9 +186,10 @@ All LLM settings live in a single JSON configuration file. Environment variables
 
 ### Configuration options
 
-- **`llm`** — main LLM configuration. Optional keys include `temperature`, `max_tokens`, `timeout`, `reasoning_effort`, `context_window`, and `stream`. Values such as `reasoning_effort` are passed to the API as-is when set. `context_window` (tokens) overrides the built-in table for the active model; when unset, well-known models are matched automatically. `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`. Each profile can include `context_window` to set the context window for that model. `default` restores the main LLM configuration.
-- **`subagent_llm`** — LLM configuration for `Agent` tool requests. Unset values inherit from the main `llm`. Set `profile` to reuse a profile from `models`. `context_window` can also be set here to override the inherited value for sub-agents. Precedence is: profile settings > explicit `subagent_llm` settings > main `llm` > environment variables.
+- **`llm`** — main LLM configuration. Optional keys include `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`.
 - **Configuration precedence** — code defaults < config file < `OPENAI_*` environment variables. Sub-agent settings also support `OPENAI_SUBAGENT_*` (`_BASE_URL`, `_API_KEY`, `_MODEL`).

{python_agent_harness-1.5.4.6 → python_agent_harness-1.5.4.8}/README.md

@@ -115,15 +115,17 @@ All LLM settings live in a single JSON configuration file. Environment variables
     "_comment": "Named LLM profiles for /model switching. Partial settings; unset keys inherit the main llm.",
     "deepseek": {
       "base_url": "https://api.deepseek.com/v1",
-      "model": "deepseek-chat",
-      "context_window": 128000
+      "model": "deepseek-chat"
     },
     "qwen": {
       "base_url": "https://dashscope.aliyuncs.com/compatible-mode/v1",
-      "model": "qwen3.5-coder",
-      "context_window": 131072
+      "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,
@@ -133,8 +135,7 @@ All LLM settings live in a single JSON configuration file. Environment variables
     "max_tokens": null,
     "timeout": null,
     "reasoning_effort": null,
-    "stream": null,
-    "context_window": null
+    "stream": null
   },
   "paths": {
     "context_path": null,
@@ -162,9 +163,10 @@ All LLM settings live in a single JSON configuration file. Environment variables
 
 ### Configuration options
 
-- **`llm`** — main LLM configuration. Optional keys include `temperature`, `max_tokens`, `timeout`, `reasoning_effort`, `context_window`, and `stream`. Values such as `reasoning_effort` are passed to the API as-is when set. `context_window` (tokens) overrides the built-in table for the active model; when unset, well-known models are matched automatically. `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`. Each profile can include `context_window` to set the context window for that model. `default` restores the main LLM configuration.
-- **`subagent_llm`** — LLM configuration for `Agent` tool requests. Unset values inherit from the main `llm`. Set `profile` to reuse a profile from `models`. `context_window` can also be set here to override the inherited value for sub-agents. Precedence is: profile settings > explicit `subagent_llm` settings > main `llm` > environment variables.
+- **`llm`** — main LLM configuration. Optional keys include `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`.
 - **Configuration precedence** — code defaults < config file < `OPENAI_*` environment variables. Sub-agent settings also support `OPENAI_SUBAGENT_*` (`_BASE_URL`, `_API_KEY`, `_MODEL`).

{python_agent_harness-1.5.4.6 → python_agent_harness-1.5.4.8}/pyproject.toml

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

{python_agent_harness-1.5.4.6 → python_agent_harness-1.5.4.8}/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.6"
+__version__ = "1.5.4.8"
 
 __all__ = [
     "Session",

{python_agent_harness-1.5.4.6 → python_agent_harness-1.5.4.8}/python_agent_harness/cli.py

@@ -217,11 +217,17 @@ def cmd_config(args: argparse.Namespace) -> int:
         for name, profile in sorted(model_profiles.items()):
             model_name = profile.get("model", "(inherited)")
             base_url = profile.get("base_url", "(inherited)")
-            cw = profile.get("context_window")
-            cw_str = f", context_window={cw}" if cw is not None else ""
-            print(f"  {name}: model={model_name}, base_url={base_url}{cw_str}")
+            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.6 → python_agent_harness-1.5.4.8}/python_agent_harness/client.py

@@ -217,10 +217,6 @@ class Client:
         # the user asked to stop.  Cleared at the start of each chat()
         # so a fresh turn may retry normally.
         self._aborted = False
-        # Per-model context-window override: set by the session when
-        # switching to a model profile that carries its own
-        # context_window.  None means "resolve from config / table".
-        self._context_window: int | None = None
         # an explicit log file is inherited by clones so every request
         # of one session (main + all sub-agents) lands in a single log
         self.log_path = (
@@ -233,21 +229,18 @@ class Client:
     def context_window(self) -> int:
         """Get the context window for this model.
 
-        Resolution order: explicit ``_context_window`` override (set by
-        the session on model switch) → ``llm.context_window`` from the
-        config file → built-in CONTEXT_WINDOWS table (substring 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.
+        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.
         """
-        if self._context_window is not None:
-            return self._context_window
         try:
             return config.get_context_window_for_model(self.model, config_path=self._config_path)
         except Exception:
-            # a malformed config must not break the loop: use the safe
-            # default, retry on the next access
+            # 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:
@@ -266,7 +259,7 @@ class Client:
         flag strictly per-request.  The log file is shared so one
         session's LLM interactions stay in one log.
         """
-        c = Client(
+        return Client(
             base_url=self.base_url,
             api_key=self.api_key,
             model=self.model,
@@ -278,20 +271,22 @@ class Client:
             config_path=self._config_path,
             log_path=self.log_path,
         )
-        c._context_window = self._context_window
-        return c
 
     def abort(self) -> None:
         """Abort the in-flight request (called on cancel).
 
         A blocked ``iter_lines()`` read must be interrupted so the agent
         loop can stop promptly.  Closing the pool alone is NOT enough:
-        on Linux, ``close()`` from another thread cannot wake a ``recv``
-        that is already blocked in the kernel.  So we first
-        ``shutdown(SHUT_RDWR)`` every in-flight connection socket (which
-        does wake the blocked read, turning it into a connection error
-        the loop treats as a cancel) and then close the pool.  A fresh
-        client is swapped in for the next request.
+        ``httpx.Client.close()`` from another thread cannot force-close a
+        socket whose fd is parked in a kernel ``recv``.  So we first
+        reach into every in-flight connection socket and both
+        ``shutdown(SHUT_RDWR)`` it (wakes the blocked read on Linux) and
+        ``close()`` the raw fd (the reliable wake on macOS/BSD, where
+        ``shutdown`` alone may not rouse a parked ``recv``); the woken
+        read surfaces as a connection error the loop treats as a cancel.
+        We then close the pool and swap in a fresh client for the next
+        request.  See ``_abort_inflight_sockets`` for the platform
+        details.
         """
         self._aborted = True
         old = self._http
@@ -828,15 +823,31 @@ def _default_api_key() -> str | None:
 
 
 def _abort_inflight_sockets(client: httpx.Client) -> None:
-    """Wake any blocked stream reads by shutting down live pool sockets.
+    """Wake any blocked stream reads on every live pool socket.
 
     Reaches through httpx/httpcore internals (transport -> pool ->
-    connection -> network stream -> raw socket) and calls
-    ``shutdown(SHUT_RDWR)`` on each live connection.  On Linux this is
-    the only reliable way to interrupt a ``recv`` already blocked in the
-    kernel from another thread — ``close()`` cannot do it.  Shutting
-    down an idle socket is harmless (the pool is closed right after
-    anyway); any failure is ignored (best effort).
+    connection -> network stream -> raw socket) and, for each live
+    connection, both ``shutdown(SHUT_RDWR)`` AND ``close()`` the raw
+    socket.
+
+    Both steps are needed for cross-platform reliability when another
+    thread is already blocked in ``recv``:
+
+    - On Linux, ``shutdown(SHUT_RDWR)`` reliably wakes the blocked
+      ``recv`` (turning it into a clean EOF / connection error), while
+      httpx's own ``close()`` cannot — it can't force-close a socket
+      whose fd is parked in a kernel read.
+    - On macOS/BSD (notably CI's macos-latest on py3.11), ``shutdown``
+      from another thread is NOT guaranteed to wake a ``recv`` already
+      parked in the kernel; the read stays blocked until the fd itself
+      is closed.  ``socket.close()`` closes the fd directly and does
+      wake it, so we always follow the shutdown with an explicit
+      close.
+
+    Closing the fd out from under httpcore is safe here: ``abort()``
+    swaps in a fresh pool immediately and closes the old one under
+    ``contextlib.suppress`` right after this call, so a double-close is
+    harmless.  Every step is best-effort; any failure is ignored.
     """
     pool = getattr(getattr(client, "_transport", None), "_pool", None)
     for conn in getattr(pool, "_connections", None) or ():
@@ -846,8 +857,13 @@ def _abort_inflight_sockets(client: httpx.Client) -> None:
         except Exception:  # noqa: BLE001 - best effort
             sock = None
         if sock is not None:
+            # shutdown first (wakes the recv on Linux without touching
+            # the fd), then close the fd (the reliable wake on
+            # macOS/BSD, where shutdown alone may not).
             with contextlib.suppress(OSError):
                 sock.shutdown(_socket.SHUT_RDWR)
+            with contextlib.suppress(OSError):
+                sock.close()
 
 
 def _iter_sse(lines: Iterator[str]) -> Iterator[str]:

{python_agent_harness-1.5.4.6 → python_agent_harness-1.5.4.8}/python_agent_harness/config.py

@@ -7,7 +7,6 @@ from __future__ import annotations
 
 import json
 import os
-import warnings
 from pathlib import Path
 
 from .mcp.config import MCPConfig
@@ -174,7 +173,6 @@ DEFAULT_LLM: dict = {
     "timeout": 600.0,
     "reasoning_effort": None,
     "stream": True,
-    "context_window": None,
 }
 
 DEFAULT_PATHS: dict = {
@@ -198,7 +196,6 @@ DEFAULT_SUBAGENT_LLM: dict = {
     "timeout": None,
     "reasoning_effort": None,
     "stream": None,
-    "context_window": None,
 }
 
 CONFIG_TEMPLATE = """\
@@ -211,18 +208,20 @@ CONFIG_TEMPLATE = """\
     "stream": true
   }},
   "models": {{
-    "_comment": "Named LLM profiles for /model switching. Each entry is a full set of LLM settings (base_url, api_key, model, context_window, etc.). Use /model in the TUI to switch at runtime. Unset keys inherit the main llm settings.",
+    "_comment": "Named LLM profiles for /model switching. Each entry is a full set of LLM settings (base_url, api_key, model, etc.). Use /model in the TUI to switch at runtime.",
     "deepseek": {{
       "base_url": "https://api.deepseek.com/v1",
-      "model": "deepseek-chat",
-      "context_window": 128000
+      "model": "deepseek-chat"
     }},
     "openai": {{
       "base_url": "https://api.openai.com/v1",
-      "model": "gpt-5-mini",
-      "context_window": 128000
+      "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,
@@ -233,8 +232,7 @@ CONFIG_TEMPLATE = """\
     "max_tokens": null,
     "timeout": null,
     "reasoning_effort": null,
-    "stream": null,
-    "context_window": null
+    "stream": null
   }},
   "paths": {{
     "_comment": "Optional overrides for context and skill directories. Absolute paths or ~ expansion supported.",
@@ -272,22 +270,6 @@ _SUBAGENT_ENV_OVERRIDES = {
 }
 
 
-def _validate_context_window(
-    value: object, section: str, path: str | os.PathLike | None = None
-) -> None:
-    """Raise ValueError if *value* is set but not a positive integer."""
-    if value is None:
-        return
-    if isinstance(value, bool) or not isinstance(value, int):
-        raise ValueError(
-            f"config file {_config_path(path)}: {section}.context_window must be an integer"
-        )
-    if value <= 0:
-        raise ValueError(
-            f"config file {_config_path(path)}: {section}.context_window must be positive"
-        )
-
-
 def _config_path(path: str | os.PathLike | None = None) -> Path:
     """Resolve the config file path: explicit arg > $PYTHON_AGENT_HARNESS_CONFIG > default."""
     if path:
@@ -323,9 +305,6 @@ def load_llm_config(path: str | os.PathLike | None = None) -> dict:
 
     The config file is JSON with an ``llm`` object (see `CONFIG_TEMPLATE`).
     Environment variables still win if set, so existing setups keep working.
-    ``context_window`` is an optional integer (tokens); when unset it
-    defaults to None, meaning "resolve from the built-in table at
-    runtime".
     """
     settings = dict(DEFAULT_LLM)
     data = _read_config(path)
@@ -341,19 +320,9 @@ def load_llm_config(path: str | os.PathLike | None = None) -> dict:
         "timeout",
         "reasoning_effort",
         "stream",
-        "context_window",
     ):
         if key in llm and llm[key] is not None:
             settings[key] = llm[key]
-    _validate_context_window(settings.get("context_window"), "llm", path)
-    # Warn if the old top-level context_windows section is still present.
-    if data.get("context_windows"):
-        warnings.warn(
-            "The top-level 'context_windows' section in config.json is deprecated and ignored. "
-            "Set 'context_window' inside 'llm' or each model profile in 'models' instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
     for key, env in _ENV_OVERRIDES.items():
         val = os.environ.get(env)
         if val:
@@ -409,7 +378,6 @@ def load_subagent_llm_config(
             "timeout",
             "reasoning_effort",
             "stream",
-            "context_window",
         ):
             if key in profile and profile[key] is not None:
                 overrides[key] = profile[key]
@@ -505,62 +473,65 @@ def _match_context_window(model: str) -> int | None:
     return None
 
 
-def get_context_window_for_model(
-    model: str,
-    config_path: str | os.PathLike | None = None,
-) -> int:
-    """Get the context window for MODEL.
-
-    Resolution order:
-    1. ``llm.context_window`` from the config file (when the active
-       model matches — this is already baked into the settings dict
-       returned by ``load_llm_config``; callers that use a resolved
-       settings dict should prefer ``resolve_context_window`` instead).
-    2. Built-in CONTEXT_WINDOWS table (substring match, first wins).
-    3. DEFAULT_CONTEXT_WINDOW.
-
-    This function is the fallback for callers that only have a model
-    name and no resolved settings dict (e.g. ``token_estimator``
-    or ``FakeClient``).
+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 the llm.context_window from the config file first.
     try:
-        data = _read_config(config_path)
+        data = _read_config(path)
     except ValueError:
-        data = {}
-    llm = data.get("llm") or {}
-    if isinstance(llm, dict):
-        cw = llm.get("context_window")
-        if cw is not None and isinstance(cw, int) and not isinstance(cw, bool) and cw > 0:
-            return cw
-    # Fall back to the built-in table, then the default.
-    matched = _match_context_window(model)
-    if matched is not None:
-        return matched
-    return DEFAULT_CONTEXT_WINDOW
+        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"
+            )
+        if size <= 0:
+            raise ValueError(
+                f"config file {_config_path(path)}: context_windows.{pattern} must be positive"
+            )
+        entries.append((pattern, size))
+    return entries
 
 
-def resolve_context_window(settings: dict, model: str | None = None) -> int:
-    """Resolve the context window from a fully-merged settings dict.
+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.
 
-    Precedence:
-    1. ``settings["context_window"]`` — set by the active profile,
-       ``llm`` section, or ``subagent_llm`` section (already merged
-       by the load functions).
-    2. Built-in CONTEXT_WINDOWS table (substring match on *model*).
-    3. DEFAULT_CONTEXT_WINDOW.
+    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:
-        settings: A resolved LLM settings dict (from ``load_llm_config``,
-            ``load_subagent_llm_config``, or a merged profile).
-        model: The model ID to match against the built-in table when
-            ``context_window`` is not set.  Defaults to
-            ``settings["model"]`` when omitted.
+        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.
     """
-    cw = settings.get("context_window")
-    if cw is not None and isinstance(cw, int) and not isinstance(cw, bool) and cw > 0:
-        return cw
-    model = model or settings.get("model") or ""
+    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

{python_agent_harness-1.5.4.6 → python_agent_harness-1.5.4.8}/python_agent_harness/planmode.py

@@ -112,4 +112,6 @@ class PlanMode:
         return self.mode == AgentMode.PLAN
 
     def plan_reminder(self) -> str:
-        return config.PLAN_MODE_SUBAGENT_REMINDER % (self.plan_file or self.plan_file_path())
+        return config.PLAN_MODE_SUBAGENT_REMINDER.replace(
+            "%s", self.plan_file or self.plan_file_path()
+        )

{python_agent_harness-1.5.4.6 → python_agent_harness-1.5.4.8}/python_agent_harness/session.py

@@ -444,7 +444,7 @@ class Session:
         )
         if approved:
             self.switch_to_build()
-            msg = config.PLAN_EXIT_APPROVED_MESSAGE % (self.plan_mode.plan_file or "")
+            msg = config.PLAN_EXIT_APPROVED_MESSAGE.replace("%s", self.plan_mode.plan_file or "")
             self.pending_user_prompts.append(msg)
             return (
                 "User approved switching to build agent.  You are now in "
@@ -661,7 +661,6 @@ class Session:
             "timeout": self.client.timeout,
             "reasoning_effort": self.reasoning_effort,
             "stream": self.stream,
-            "context_window": getattr(self.client, "_context_window", None),
         }
         for key, val in current.items():
             merged.setdefault(key, val)
@@ -675,7 +674,6 @@ class Session:
                 "timeout",
                 "reasoning_effort",
                 "stream",
-                "context_window",
             ):
                 if key in profile and profile[key] is not None:
                     merged[key] = profile[key]
@@ -695,10 +693,6 @@ class Session:
             self.client.timeout = merged["timeout"]
         self.reasoning_effort = merged["reasoning_effort"]
         self.stream = merged["stream"]
-        # context_window: set the client override so subsequent
-        # client.context_window accesses use the profile's value
-        # (None means "resolve from config / built-in table").
-        self.client._context_window = merged.get("context_window")
         return True, f"switched to {name} ({self.model})"
 
     # ------------------------------------------------------------------

{python_agent_harness-1.5.4.6 → python_agent_harness-1.5.4.8}/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
-    ``llm.context_window`` first, then substring match 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.

{python_agent_harness-1.5.4.6 → python_agent_harness-1.5.4.8}/python_agent_harness/tools/edit.py

@@ -90,7 +90,7 @@ class Edit(Tool):
         if old is None:
             return "Error: old_str is required for non-diff edits"
         try:
-            with open(path, encoding="utf-8") as f:
+            with open(path, encoding="utf-8", errors="replace") as f:
                 content = f.read()
         except OSError as e:
             return f"Error: cannot read {path}: {e}"

{python_agent_harness-1.5.4.6 → python_agent_harness-1.5.4.8}/python_agent_harness/tools/glob.py

@@ -107,7 +107,7 @@ class GlobTool(Tool):
                 return f"Error: {e}"
             if proc.returncode != 0:
                 # Failure banner is prepended to whatever git emitted.
-                banner = f"Glob failed with exit code {proc.returncode}\n.STDOUT:\n\n"
+                banner = f"Glob failed with exit code {proc.returncode}\nSTDOUT:\n\n"
                 return _spool(banner + (proc.stdout or "") + (proc.stderr or ""), "glob")
             return _git_glob_results(proc.stdout, git_root, base, depth)
 
@@ -141,7 +141,7 @@ class GlobTool(Tool):
             return f"Error: {e}"
         out = proc.stdout
         if proc.returncode != 0:
-            out = f"Glob failed with exit code {proc.returncode}\n.STDOUT:\n\n" + out
+            out = f"Glob failed with exit code {proc.returncode}\nSTDOUT:\n\n" + out
         return _spool(out, "glob")